![[BACK]](/icons/back.gif){kind=icon}
Return to option.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / less|
Return to option.c CVS log | Up to [local] / src / usr.bin / less |
1.1 ! etheisen 1: /*
! 2: * Copyright (c) 1984,1985,1989,1994,1995 Mark Nudelman
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice in the documentation and/or other materials provided with
! 12: * the distribution.
! 13: *
! 14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
! 15: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 17: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
! 18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 19: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
! 20: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
! 21: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
! 23: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
! 24: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 25: */
! 26:
! 27:
! 28: /*
! 29: * Process command line options.
! 30: *
! 31: * Each option is a single letter which controls a program variable.
! 32: * The options have defaults which may be changed via
! 33: * the command line option, toggled via the "-" command,
! 34: * or queried via the "_" command.
! 35: */
! 36:
! 37: #include "less.h"
! 38: #include "option.h"
! 39:
! 40: static struct option *pendopt;
! 41: public int plusoption = FALSE;
! 42:
! 43: static char *propt();
! 44: static char *optstring();
! 45: static int flip_triple();
! 46:
! 47: extern int screen_trashed;
! 48: extern char *every_first_cmd;
! 49:
! 50: /*
! 51: * Scan an argument (either from the command line or from the
! 52: * LESS environment variable) and process it.
! 53: */
! 54: public void
! 55: scan_option(s)
! 56: char *s;
! 57: {
! 58: register struct option *o;
! 59: register int c;
! 60: char *str;
! 61: int set_default;
! 62: PARG parg;
! 63:
! 64: if (s == NULL)
! 65: return;
! 66:
! 67: /*
! 68: * If we have a pending string-valued option, handle it now.
! 69: * This happens if the previous option was, for example, "-P"
! 70: * without a following string. In that case, the current
! 71: * option is simply the string for the previous option.
! 72: */
! 73: if (pendopt != NULL)
! 74: {
! 75: (*pendopt->ofunc)(INIT, s);
! 76: pendopt = NULL;
! 77: return;
! 78: }
! 79:
! 80: set_default = FALSE;
! 81:
! 82: while (*s != '\0')
! 83: {
! 84: /*
! 85: * Check some special cases first.
! 86: */
! 87: switch (c = *s++)
! 88: {
! 89: case ' ':
! 90: case '\t':
! 91: case END_OPTION_STRING:
! 92: continue;
! 93: case '-':
! 94: /*
! 95: * "-+" means set these options back to their defaults.
! 96: * (They may have been set otherwise by previous
! 97: * options.)
! 98: */
! 99: if (set_default = (*s == '+'))
! 100: s++;
! 101: continue;
! 102: case '+':
! 103: /*
! 104: * An option prefixed by a "+" is ungotten, so
! 105: * that it is interpreted as less commands
! 106: * processed at the start of the first input file.
! 107: * "++" means process the commands at the start of
! 108: * EVERY input file.
! 109: */
! 110: plusoption = TRUE;
! 111: if (*s == '+')
! 112: every_first_cmd = save(++s);
! 113: else
! 114: ungetsc(s);
! 115: s = optstring(s, c);
! 116: continue;
! 117: case '0': case '1': case '2': case '3': case '4':
! 118: case '5': case '6': case '7': case '8': case '9':
! 119: /*
! 120: * Special "more" compatibility form "-<number>"
! 121: * instead of -z<number> to set the scrolling
! 122: * window size.
! 123: */
! 124: s--;
! 125: c = 'z';
! 126: break;
! 127: }
! 128:
! 129: /*
! 130: * Not a special case.
! 131: * Look up the option letter in the option table.
! 132: */
! 133: o = findopt(c);
! 134: if (o == NULL)
! 135: {
! 136: parg.p_string = propt(c);
! 137: #if MSOFTC || OS2
! 138: error("There is no %s flag (\"less -?\" for help)",
! 139: &parg);
! 140: #else
! 141: error("There is no %s flag (\"less -\\?\" for help)",
! 142: &parg);
! 143: #endif
! 144: quit(QUIT_ERROR);
! 145: }
! 146:
! 147: switch (o->otype & OTYPE)
! 148: {
! 149: case BOOL:
! 150: if (set_default)
! 151: *(o->ovar) = o->odefault;
! 152: else
! 153: *(o->ovar) = ! o->odefault;
! 154: break;
! 155: case TRIPLE:
! 156: if (set_default)
! 157: *(o->ovar) = o->odefault;
! 158: else
! 159: *(o->ovar) = flip_triple(o->odefault,
! 160: (o->oletter == c));
! 161: break;
! 162: case STRING:
! 163: if (*s == '\0')
! 164: {
! 165: /*
! 166: * Set pendopt and return.
! 167: * We will get the string next time
! 168: * scan_option is called.
! 169: */
! 170: pendopt = o;
! 171: return;
! 172: }
! 173: /*
! 174: * Don't do anything here.
! 175: * All processing of STRING options is done by
! 176: * the handling function.
! 177: */
! 178: str = s;
! 179: s = optstring(s, c);
! 180: break;
! 181: case NUMBER:
! 182: *(o->ovar) = getnum(&s, c, (int*)NULL);
! 183: break;
! 184: }
! 185: /*
! 186: * If the option has a handling function, call it.
! 187: */
! 188: if (o->ofunc != NULL)
! 189: (*o->ofunc)(INIT, str);
! 190: }
! 191: }
! 192:
! 193: /*
! 194: * Toggle command line flags from within the program.
! 195: * Used by the "-" and "_" commands.
! 196: * how_toggle may be:
! 197: * OPT_NO_TOGGLE just report the current setting, without changing it.
! 198: * OPT_TOGGLE invert the current setting
! 199: * OPT_UNSET set to the default value
! 200: * OPT_SET set to the inverse of the default value
! 201: */
! 202: public void
! 203: toggle_option(c, s, how_toggle)
! 204: int c;
! 205: char *s;
! 206: int how_toggle;
! 207: {
! 208: register struct option *o;
! 209: register int num;
! 210: int err;
! 211: PARG parg;
! 212:
! 213: /*
! 214: * Look up the option letter in the option table.
! 215: */
! 216: o = findopt(c);
! 217: if (o == NULL)
! 218: {
! 219: parg.p_string = propt(c);
! 220: error("There is no %s flag", &parg);
! 221: return;
! 222: }
! 223:
! 224: if (how_toggle == OPT_TOGGLE && (o->otype & NO_TOGGLE))
! 225: {
! 226: parg.p_string = propt(c);
! 227: error("Cannot change the %s flag", &parg);
! 228: return;
! 229: }
! 230:
! 231: if (how_toggle == OPT_NO_TOGGLE && (o->otype & NO_QUERY))
! 232: {
! 233: parg.p_string = propt(c);
! 234: error("Cannot query the %s flag", &parg);
! 235: return;
! 236: }
! 237:
! 238: /*
! 239: * Check for something which appears to be a do_toggle
! 240: * (because the "-" command was used), but really is not.
! 241: * This could be a string option with no string, or
! 242: * a number option with no number.
! 243: */
! 244: switch (o->otype & OTYPE)
! 245: {
! 246: case STRING:
! 247: case NUMBER:
! 248: if (how_toggle == OPT_TOGGLE && *s == '\0')
! 249: how_toggle = OPT_NO_TOGGLE;
! 250: break;
! 251: }
! 252:
! 253: #if HILITE_SEARCH
! 254: if (how_toggle != OPT_NO_TOGGLE && (o->otype & HL_REPAINT))
! 255: repaint_hilite(0);
! 256: #endif
! 257:
! 258: /*
! 259: * Now actually toggle (change) the variable.
! 260: */
! 261: if (how_toggle != OPT_NO_TOGGLE)
! 262: {
! 263: switch (o->otype & OTYPE)
! 264: {
! 265: case BOOL:
! 266: /*
! 267: * Boolean.
! 268: */
! 269: switch (how_toggle)
! 270: {
! 271: case OPT_TOGGLE:
! 272: *(o->ovar) = ! *(o->ovar);
! 273: break;
! 274: case OPT_UNSET:
! 275: *(o->ovar) = o->odefault;
! 276: break;
! 277: case OPT_SET:
! 278: *(o->ovar) = ! o->odefault;
! 279: break;
! 280: }
! 281: break;
! 282: case TRIPLE:
! 283: /*
! 284: * Triple:
! 285: * If user gave the lower case letter, then switch
! 286: * to 1 unless already 1, in which case make it 0.
! 287: * If user gave the upper case letter, then switch
! 288: * to 2 unless already 2, in which case make it 0.
! 289: */
! 290: switch (how_toggle)
! 291: {
! 292: case OPT_TOGGLE:
! 293: *(o->ovar) = flip_triple(*(o->ovar),
! 294: o->oletter == c);
! 295: break;
! 296: case OPT_UNSET:
! 297: *(o->ovar) = o->odefault;
! 298: break;
! 299: case OPT_SET:
! 300: *(o->ovar) = flip_triple(o->odefault,
! 301: o->oletter == c);
! 302: break;
! 303: }
! 304: break;
! 305: case STRING:
! 306: /*
! 307: * String: don't do anything here.
! 308: * The handling function will do everything.
! 309: */
! 310: switch (how_toggle)
! 311: {
! 312: case OPT_SET:
! 313: case OPT_UNSET:
! 314: error("Can't use \"-+\" or \"--\" for a string flag",
! 315: NULL_PARG);
! 316: return;
! 317: }
! 318: break;
! 319: case NUMBER:
! 320: /*
! 321: * Number: set the variable to the given number.
! 322: */
! 323: switch (how_toggle)
! 324: {
! 325: case OPT_TOGGLE:
! 326: num = getnum(&s, '\0', &err);
! 327: if (!err)
! 328: *(o->ovar) = num;
! 329: break;
! 330: case OPT_UNSET:
! 331: *(o->ovar) = o->odefault;
! 332: break;
! 333: case OPT_SET:
! 334: error("Can't use \"--\" for a numeric flag",
! 335: NULL_PARG);
! 336: return;
! 337: }
! 338: break;
! 339: }
! 340: }
! 341:
! 342: /*
! 343: * Call the handling function for any special action
! 344: * specific to this option.
! 345: */
! 346: if (o->ofunc != NULL)
! 347: (*o->ofunc)((how_toggle==OPT_NO_TOGGLE) ? QUERY : TOGGLE, s);
! 348:
! 349: #if HILITE_SEARCH
! 350: if (how_toggle != OPT_NO_TOGGLE && (o->otype & HL_REPAINT))
! 351: chg_hilite();
! 352: #endif
! 353:
! 354: /*
! 355: * Print a message describing the new setting.
! 356: */
! 357: switch (o->otype & OTYPE)
! 358: {
! 359: case BOOL:
! 360: case TRIPLE:
! 361: /*
! 362: * Print the odesc message.
! 363: */
! 364: error(o->odesc[*(o->ovar)], NULL_PARG);
! 365: break;
! 366: case NUMBER:
! 367: /*
! 368: * The message is in odesc[1] and has a %d for
! 369: * the value of the variable.
! 370: */
! 371: parg.p_int = *(o->ovar);
! 372: error(o->odesc[1], &parg);
! 373: break;
! 374: case STRING:
! 375: /*
! 376: * Message was already printed by the handling function.
! 377: */
! 378: break;
! 379: }
! 380:
! 381: if (how_toggle != OPT_NO_TOGGLE && (o->otype & REPAINT))
! 382: screen_trashed = TRUE;
! 383: }
! 384:
! 385: /*
! 386: * "Toggle" a triple-valued option.
! 387: */
! 388: static int
! 389: flip_triple(val, lc)
! 390: int val;
! 391: int lc;
! 392: {
! 393: if (lc)
! 394: return ((val == OPT_ON) ? OPT_OFF : OPT_ON);
! 395: else
! 396: return ((val == OPT_ONPLUS) ? OPT_OFF : OPT_ONPLUS);
! 397: }
! 398:
! 399: /*
! 400: * Return a string suitable for printing as the "name" of an option.
! 401: * For example, if the option letter is 'x', just return "-x".
! 402: */
! 403: static char *
! 404: propt(c)
! 405: int c;
! 406: {
! 407: static char buf[8];
! 408:
! 409: sprintf(buf, "-%s", prchar(c));
! 410: return (buf);
! 411: }
! 412:
! 413: /*
! 414: * Determine if an option is a single character option (BOOL or TRIPLE),
! 415: * or if it a multi-character option (NUMBER).
! 416: */
! 417: public int
! 418: single_char_option(c)
! 419: int c;
! 420: {
! 421: register struct option *o;
! 422:
! 423: o = findopt(c);
! 424: if (o == NULL)
! 425: return (TRUE);
! 426: return ((o->otype & (BOOL|TRIPLE|NOVAR|NO_TOGGLE)) != 0);
! 427: }
! 428:
! 429: /*
! 430: * Return the prompt to be used for a given option letter.
! 431: * Only string and number valued options have prompts.
! 432: */
! 433: public char *
! 434: opt_prompt(c)
! 435: int c;
! 436: {
! 437: register struct option *o;
! 438:
! 439: o = findopt(c);
! 440: if (o == NULL || (o->otype & (STRING|NUMBER)) == 0)
! 441: return (NULL);
! 442: return (o->odesc[0]);
! 443: }
! 444:
! 445: /*
! 446: * Return whether or not there is a string option pending;
! 447: * that is, if the previous option was a string-valued option letter
! 448: * (like -P) without a following string.
! 449: * In that case, the current option is taken to be the string for
! 450: * the previous option.
! 451: */
! 452: public int
! 453: isoptpending()
! 454: {
! 455: return (pendopt != NULL);
! 456: }
! 457:
! 458: /*
! 459: * Print error message about missing string.
! 460: */
! 461: static void
! 462: nostring(c)
! 463: int c;
! 464: {
! 465: PARG parg;
! 466: parg.p_string = propt(c);
! 467: error("String is required after %s", &parg);
! 468: }
! 469:
! 470: /*
! 471: * Print error message if a STRING type option is not followed by a string.
! 472: */
! 473: public void
! 474: nopendopt()
! 475: {
! 476: nostring(pendopt->oletter);
! 477: }
! 478:
! 479: /*
! 480: * Scan to end of string or to an END_OPTION_STRING character.
! 481: * In the latter case, replace the char with a null char.
! 482: * Return a pointer to the remainder of the string, if any.
! 483: */
! 484: static char *
! 485: optstring(s, c)
! 486: char *s;
! 487: int c;
! 488: {
! 489: register char *p;
! 490:
! 491: if (*s == '\0')
! 492: {
! 493: nostring(c);
! 494: quit(QUIT_ERROR);
! 495: }
! 496: for (p = s; *p != '\0'; p++)
! 497: if (*p == END_OPTION_STRING)
! 498: {
! 499: *p = '\0';
! 500: return (p+1);
! 501: }
! 502: return (p);
! 503: }
! 504:
! 505: /*
! 506: * Translate a string into a number.
! 507: * Like atoi(), but takes a pointer to a char *, and updates
! 508: * the char * to point after the translated number.
! 509: */
! 510: public int
! 511: getnum(sp, c, errp)
! 512: char **sp;
! 513: int c;
! 514: int *errp;
! 515: {
! 516: register char *s;
! 517: register int n;
! 518: register int neg;
! 519: PARG parg;
! 520:
! 521: s = skipsp(*sp);
! 522: neg = FALSE;
! 523: if (*s == '-')
! 524: {
! 525: neg = TRUE;
! 526: s++;
! 527: }
! 528: if (*s < '0' || *s > '9')
! 529: {
! 530: if (errp != NULL)
! 531: {
! 532: *errp = TRUE;
! 533: return (-1);
! 534: }
! 535: parg.p_string = propt(c);
! 536: error("Number is required after %s", &parg);
! 537: quit(QUIT_ERROR);
! 538: }
! 539:
! 540: n = 0;
! 541: while (*s >= '0' && *s <= '9')
! 542: n = 10 * n + *s++ - '0';
! 543: *sp = s;
! 544: if (errp != NULL)
! 545: *errp = FALSE;
! 546: if (neg)
! 547: n = -n;
! 548: return (n);
! 549: }