contrib/less/option.c

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