1 /* 2 * Copyright (C) 1984-2014 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11 /* 12 * Process command line options. 13 * 14 * Each option is a single letter which controls a program variable. 15 * The options have defaults which may be changed via 16 * the command line option, toggled via the "-" command, 17 * or queried via the "_" command. 18 */ 19 20 #include "less.h" 21 #include "option.h" 22 23 static struct loption *pendopt; 24 public int plusoption = FALSE; 25 26 static char *optstring(); 27 static int flip_triple(); 28 29 extern int screen_trashed; 30 extern int less_is_more; 31 extern int quit_at_eof; 32 extern char *every_first_cmd; 33 extern int opt_use_backslash; 34 35 /* 36 * Return a printable description of an option. 37 */ 38 static char * 39 opt_desc(o) 40 struct loption *o; 41 { 42 static char buf[OPTNAME_MAX + 10]; 43 if (o->oletter == OLETTER_NONE) 44 SNPRINTF1(buf, sizeof(buf), "--%s", o->onames->oname); 45 else 46 SNPRINTF2(buf, sizeof(buf), "-%c (--%s)", o->oletter, o->onames->oname); 47 return (buf); 48 } 49 50 /* 51 * Return a string suitable for printing as the "name" of an option. 52 * For example, if the option letter is 'x', just return "-x". 53 */ 54 public char * 55 propt(c) 56 int c; 57 { 58 static char buf[8]; 59 60 sprintf(buf, "-%s", prchar(c)); 61 return (buf); 62 } 63 64 /* 65 * Scan an argument (either from the command line or from the 66 * LESS environment variable) and process it. 67 */ 68 public void 69 scan_option(s) 70 char *s; 71 { 72 register struct loption *o; 73 register int optc; 74 char *optname; 75 char *printopt; 76 char *str; 77 int set_default; 78 int lc; 79 int err; 80 PARG parg; 81 82 if (s == NULL) 83 return; 84 85 /* 86 * If we have a pending option which requires an argument, 87 * handle it now. 88 * This happens if the previous option was, for example, "-P" 89 * without a following string. In that case, the current 90 * option is simply the argument for the previous option. 91 */ 92 if (pendopt != NULL) 93 { 94 switch (pendopt->otype & OTYPE) 95 { 96 case STRING: 97 (*pendopt->ofunc)(INIT, s); 98 break; 99 case NUMBER: 100 printopt = opt_desc(pendopt); 101 *(pendopt->ovar) = getnum(&s, printopt, (int*)NULL); 102 break; 103 } 104 pendopt = NULL; 105 return; 106 } 107 108 set_default = FALSE; 109 optname = NULL; 110 111 while (*s != '\0') 112 { 113 /* 114 * Check some special cases first. 115 */ 116 switch (optc = *s++) 117 { 118 case ' ': 119 case '\t': 120 case END_OPTION_STRING: 121 continue; 122 case '-': 123 /* 124 * "--" indicates an option name instead of a letter. 125 */ 126 if (*s == '-') 127 { 128 optname = ++s; 129 break; 130 } 131 /* 132 * "-+" means set these options back to their defaults. 133 * (They may have been set otherwise by previous 134 * options.) 135 */ 136 set_default = (*s == '+'); 137 if (set_default) 138 s++; 139 continue; 140 case '+': 141 /* 142 * An option prefixed by a "+" is ungotten, so 143 * that it is interpreted as less commands 144 * processed at the start of the first input file. 145 * "++" means process the commands at the start of 146 * EVERY input file. 147 */ 148 plusoption = TRUE; 149 s = optstring(s, &str, propt('+'), NULL); 150 if (s == NULL) 151 return; 152 if (*str == '+') 153 every_first_cmd = save(str+1); 154 else 155 { 156 ungetcc(CHAR_END_COMMAND); 157 ungetsc(str); 158 } 159 free(str); 160 continue; 161 case '0': case '1': case '2': case '3': case '4': 162 case '5': case '6': case '7': case '8': case '9': 163 /* 164 * Special "more" compatibility form "-<number>" 165 * instead of -z<number> to set the scrolling 166 * window size. 167 */ 168 s--; 169 optc = 'z'; 170 break; 171 case 'n': 172 if (less_is_more) 173 optc = 'z'; 174 break; 175 } 176 177 /* 178 * Not a special case. 179 * Look up the option letter in the option table. 180 */ 181 err = 0; 182 if (optname == NULL) 183 { 184 printopt = propt(optc); 185 lc = ASCII_IS_LOWER(optc); 186 o = findopt(optc); 187 } else 188 { 189 printopt = optname; 190 lc = ASCII_IS_LOWER(optname[0]); 191 o = findopt_name(&optname, NULL, &err); 192 s = optname; 193 optname = NULL; 194 if (*s == '\0' || *s == ' ') 195 { 196 /* 197 * The option name matches exactly. 198 */ 199 ; 200 } else if (*s == '=') 201 { 202 /* 203 * The option name is followed by "=value". 204 */ 205 if (o != NULL && 206 (o->otype & OTYPE) != STRING && 207 (o->otype & OTYPE) != NUMBER) 208 { 209 parg.p_string = printopt; 210 error("The %s option should not be followed by =", 211 &parg); 212 return; 213 } 214 s++; 215 } else 216 { 217 /* 218 * The specified name is longer than the 219 * real option name. 220 */ 221 o = NULL; 222 } 223 } 224 if (o == NULL) 225 { 226 parg.p_string = printopt; 227 if (err == OPT_AMBIG) 228 error("%s is an ambiguous abbreviation (\"less --help\" for help)", 229 &parg); 230 else 231 error("There is no %s option (\"less --help\" for help)", 232 &parg); 233 return; 234 } 235 236 str = NULL; 237 switch (o->otype & OTYPE) 238 { 239 case BOOL: 240 if (set_default) 241 *(o->ovar) = o->odefault; 242 else 243 *(o->ovar) = ! o->odefault; 244 break; 245 case TRIPLE: 246 if (set_default) 247 *(o->ovar) = o->odefault; 248 else 249 *(o->ovar) = flip_triple(o->odefault, lc); 250 break; 251 case STRING: 252 if (*s == '\0') 253 { 254 /* 255 * Set pendopt and return. 256 * We will get the string next time 257 * scan_option is called. 258 */ 259 pendopt = o; 260 return; 261 } 262 /* 263 * Don't do anything here. 264 * All processing of STRING options is done by 265 * the handling function. 266 */ 267 while (*s == ' ') 268 s++; 269 s = optstring(s, &str, printopt, o->odesc[1]); 270 if (s == NULL) 271 return; 272 break; 273 case NUMBER: 274 if (*s == '\0') 275 { 276 pendopt = o; 277 return; 278 } 279 *(o->ovar) = getnum(&s, printopt, (int*)NULL); 280 break; 281 } 282 /* 283 * If the option has a handling function, call it. 284 */ 285 if (o->ofunc != NULL) 286 (*o->ofunc)(INIT, str); 287 if (str != NULL) 288 free(str); 289 } 290 } 291 292 /* 293 * Toggle command line flags from within the program. 294 * Used by the "-" and "_" commands. 295 * how_toggle may be: 296 * OPT_NO_TOGGLE just report the current setting, without changing it. 297 * OPT_TOGGLE invert the current setting 298 * OPT_UNSET set to the default value 299 * OPT_SET set to the inverse of the default value 300 */ 301 public void 302 toggle_option(o, lower, s, how_toggle) 303 struct loption *o; 304 int lower; 305 char *s; 306 int how_toggle; 307 { 308 register int num; 309 int no_prompt; 310 int err; 311 PARG parg; 312 313 no_prompt = (how_toggle & OPT_NO_PROMPT); 314 how_toggle &= ~OPT_NO_PROMPT; 315 316 if (o == NULL) 317 { 318 error("No such option", NULL_PARG); 319 return; 320 } 321 322 if (how_toggle == OPT_TOGGLE && (o->otype & NO_TOGGLE)) 323 { 324 parg.p_string = opt_desc(o); 325 error("Cannot change the %s option", &parg); 326 return; 327 } 328 329 if (how_toggle == OPT_NO_TOGGLE && (o->otype & NO_QUERY)) 330 { 331 parg.p_string = opt_desc(o); 332 error("Cannot query the %s option", &parg); 333 return; 334 } 335 336 /* 337 * Check for something which appears to be a do_toggle 338 * (because the "-" command was used), but really is not. 339 * This could be a string option with no string, or 340 * a number option with no number. 341 */ 342 switch (o->otype & OTYPE) 343 { 344 case STRING: 345 case NUMBER: 346 if (how_toggle == OPT_TOGGLE && *s == '\0') 347 how_toggle = OPT_NO_TOGGLE; 348 break; 349 } 350 351 #if HILITE_SEARCH 352 if (how_toggle != OPT_NO_TOGGLE && (o->otype & HL_REPAINT)) 353 repaint_hilite(0); 354 #endif 355 356 /* 357 * Now actually toggle (change) the variable. 358 */ 359 if (how_toggle != OPT_NO_TOGGLE) 360 { 361 switch (o->otype & OTYPE) 362 { 363 case BOOL: 364 /* 365 * Boolean. 366 */ 367 switch (how_toggle) 368 { 369 case OPT_TOGGLE: 370 *(o->ovar) = ! *(o->ovar); 371 break; 372 case OPT_UNSET: 373 *(o->ovar) = o->odefault; 374 break; 375 case OPT_SET: 376 *(o->ovar) = ! o->odefault; 377 break; 378 } 379 break; 380 case TRIPLE: 381 /* 382 * Triple: 383 * If user gave the lower case letter, then switch 384 * to 1 unless already 1, in which case make it 0. 385 * If user gave the upper case letter, then switch 386 * to 2 unless already 2, in which case make it 0. 387 */ 388 switch (how_toggle) 389 { 390 case OPT_TOGGLE: 391 *(o->ovar) = flip_triple(*(o->ovar), lower); 392 break; 393 case OPT_UNSET: 394 *(o->ovar) = o->odefault; 395 break; 396 case OPT_SET: 397 *(o->ovar) = flip_triple(o->odefault, lower); 398 break; 399 } 400 break; 401 case STRING: 402 /* 403 * String: don't do anything here. 404 * The handling function will do everything. 405 */ 406 switch (how_toggle) 407 { 408 case OPT_SET: 409 case OPT_UNSET: 410 error("Cannot use \"-+\" or \"--\" for a string option", 411 NULL_PARG); 412 return; 413 } 414 break; 415 case NUMBER: 416 /* 417 * Number: set the variable to the given number. 418 */ 419 switch (how_toggle) 420 { 421 case OPT_TOGGLE: 422 num = getnum(&s, NULL, &err); 423 if (!err) 424 *(o->ovar) = num; 425 break; 426 case OPT_UNSET: 427 *(o->ovar) = o->odefault; 428 break; 429 case OPT_SET: 430 error("Can't use \"-!\" for a numeric option", 431 NULL_PARG); 432 return; 433 } 434 break; 435 } 436 } 437 438 /* 439 * Call the handling function for any special action 440 * specific to this option. 441 */ 442 if (o->ofunc != NULL) 443 (*o->ofunc)((how_toggle==OPT_NO_TOGGLE) ? QUERY : TOGGLE, s); 444 445 #if HILITE_SEARCH 446 if (how_toggle != OPT_NO_TOGGLE && (o->otype & HL_REPAINT)) 447 chg_hilite(); 448 #endif 449 450 if (!no_prompt) 451 { 452 /* 453 * Print a message describing the new setting. 454 */ 455 switch (o->otype & OTYPE) 456 { 457 case BOOL: 458 case TRIPLE: 459 /* 460 * Print the odesc message. 461 */ 462 error(o->odesc[*(o->ovar)], NULL_PARG); 463 break; 464 case NUMBER: 465 /* 466 * The message is in odesc[1] and has a %d for 467 * the value of the variable. 468 */ 469 parg.p_int = *(o->ovar); 470 error(o->odesc[1], &parg); 471 break; 472 case STRING: 473 /* 474 * Message was already printed by the handling function. 475 */ 476 break; 477 } 478 } 479 480 if (how_toggle != OPT_NO_TOGGLE && (o->otype & REPAINT)) 481 screen_trashed = TRUE; 482 } 483 484 /* 485 * "Toggle" a triple-valued option. 486 */ 487 static int 488 flip_triple(val, lc) 489 int val; 490 int lc; 491 { 492 if (lc) 493 return ((val == OPT_ON) ? OPT_OFF : OPT_ON); 494 else 495 return ((val == OPT_ONPLUS) ? OPT_OFF : OPT_ONPLUS); 496 } 497 498 /* 499 * Determine if an option takes a parameter. 500 */ 501 public int 502 opt_has_param(o) 503 struct loption *o; 504 { 505 if (o == NULL) 506 return (0); 507 if (o->otype & (BOOL|TRIPLE|NOVAR|NO_TOGGLE)) 508 return (0); 509 return (1); 510 } 511 512 /* 513 * Return the prompt to be used for a given option letter. 514 * Only string and number valued options have prompts. 515 */ 516 public char * 517 opt_prompt(o) 518 struct loption *o; 519 { 520 if (o == NULL || (o->otype & (STRING|NUMBER)) == 0) 521 return ("?"); 522 return (o->odesc[0]); 523 } 524 525 /* 526 * Return whether or not there is a string option pending; 527 * that is, if the previous option was a string-valued option letter 528 * (like -P) without a following string. 529 * In that case, the current option is taken to be the string for 530 * the previous option. 531 */ 532 public int 533 isoptpending() 534 { 535 return (pendopt != NULL); 536 } 537 538 /* 539 * Print error message about missing string. 540 */ 541 static void 542 nostring(printopt) 543 char *printopt; 544 { 545 PARG parg; 546 parg.p_string = printopt; 547 error("Value is required after %s", &parg); 548 } 549 550 /* 551 * Print error message if a STRING type option is not followed by a string. 552 */ 553 public void 554 nopendopt() 555 { 556 nostring(opt_desc(pendopt)); 557 } 558 559 /* 560 * Scan to end of string or to an END_OPTION_STRING character. 561 * In the latter case, replace the char with a null char. 562 * Return a pointer to the remainder of the string, if any. 563 */ 564 static char * 565 optstring(s, p_str, printopt, validchars) 566 char *s; 567 char **p_str; 568 char *printopt; 569 char *validchars; 570 { 571 register char *p; 572 register char *out; 573 574 if (*s == '\0') 575 { 576 nostring(printopt); 577 return (NULL); 578 } 579 /* Alloc could be more than needed, but not worth trimming. */ 580 *p_str = (char *) ecalloc(strlen(s)+1, sizeof(char)); 581 out = *p_str; 582 583 for (p = s; *p != '\0'; p++) 584 { 585 if (opt_use_backslash && *p == '\\' && p[1] != '\0') 586 { 587 /* Take next char literally. */ 588 ++p; 589 } else 590 { 591 if (*p == END_OPTION_STRING || 592 (validchars != NULL && strchr(validchars, *p) == NULL)) 593 /* End of option string. */ 594 break; 595 } 596 *out++ = *p; 597 } 598 *out = '\0'; 599 return (p); 600 } 601 602 /* 603 */ 604 static int 605 num_error(printopt, errp) 606 char *printopt; 607 int *errp; 608 { 609 PARG parg; 610 611 if (errp != NULL) 612 { 613 *errp = TRUE; 614 return (-1); 615 } 616 if (printopt != NULL) 617 { 618 parg.p_string = printopt; 619 error("Number is required after %s", &parg); 620 } 621 return (-1); 622 } 623 624 /* 625 * Translate a string into a number. 626 * Like atoi(), but takes a pointer to a char *, and updates 627 * the char * to point after the translated number. 628 */ 629 public int 630 getnum(sp, printopt, errp) 631 char **sp; 632 char *printopt; 633 int *errp; 634 { 635 register char *s; 636 register int n; 637 register int neg; 638 639 s = skipsp(*sp); 640 neg = FALSE; 641 if (*s == '-') 642 { 643 neg = TRUE; 644 s++; 645 } 646 if (*s < '0' || *s > '9') 647 return (num_error(printopt, errp)); 648 649 n = 0; 650 while (*s >= '0' && *s <= '9') 651 n = 10 * n + *s++ - '0'; 652 *sp = s; 653 if (errp != NULL) 654 *errp = FALSE; 655 if (neg) 656 n = -n; 657 return (n); 658 } 659 660 /* 661 * Translate a string into a fraction, represented by the part of a 662 * number which would follow a decimal point. 663 * The value of the fraction is returned as parts per NUM_FRAC_DENOM. 664 * That is, if "n" is returned, the fraction intended is n/NUM_FRAC_DENOM. 665 */ 666 public long 667 getfraction(sp, printopt, errp) 668 char **sp; 669 char *printopt; 670 int *errp; 671 { 672 register char *s; 673 long frac = 0; 674 int fraclen = 0; 675 676 s = skipsp(*sp); 677 if (*s < '0' || *s > '9') 678 return (num_error(printopt, errp)); 679 680 for ( ; *s >= '0' && *s <= '9'; s++) 681 { 682 frac = (frac * 10) + (*s - '0'); 683 fraclen++; 684 } 685 if (fraclen > NUM_LOG_FRAC_DENOM) 686 while (fraclen-- > NUM_LOG_FRAC_DENOM) 687 frac /= 10; 688 else 689 while (fraclen++ < NUM_LOG_FRAC_DENOM) 690 frac *= 10; 691 *sp = s; 692 if (errp != NULL) 693 *errp = FALSE; 694 return (frac); 695 } 696 697 698 /* 699 * Get the value of the -e flag. 700 */ 701 public int 702 get_quit_at_eof() 703 { 704 if (!less_is_more) 705 return quit_at_eof; 706 /* When less_is_more is set, the -e flag semantics are different. */ 707 return quit_at_eof ? OPT_ONPLUS : OPT_ON; 708 } 709