lib/getopt.c

   1 /* Getopt for GNU.
   2    NOTE: getopt is now part of the C library, so if you don't know what
   3    "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
   4    before changing it!
   5
   6    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94
   7         Free Software Foundation, Inc.
   8
   9    This program is free software; you can redistribute it and/or modify it
  10    under the terms of the GNU General Public License as published by the
  11    Free Software Foundation; either version 2, or (at your option) any
  12    later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22 \f
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #if !defined (__STDC__) || !__STDC__
  28 /* This is a separate conditional since some stdc systems
  29    reject `defined (const)'.  */
  30 #ifndef const
  31 #define const
  32 #endif
  33 #endif
  34
  35 #define getopt _sys_getopt
  36 #include <stdio.h>
  37 #undef getopt
  38
  39 /* Comment out all this code if we are using the GNU C Library, and are not
  40    actually compiling the library itself.  This code is part of the GNU C
  41    Library, but also included in many other GNU distributions.  Compiling
  42    and linking in this code is a waste when using the GNU C library
  43    (especially if it is a shared library).  Rather than having every GNU
  44    program understand `configure --with-gnu-libc' and omit the object files,
  45    it is simpler to just do this in the source for each such file.  */
  46
  47 #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
  48
  49 #define getopt _sys_getopt
  50 #include <stdlib.h>
  51 #undef getopt
  52
  53 /* This version of `getopt' appears to the caller like standard Unix `getopt'
  54    but it behaves differently for the user, since it allows the user
  55    to intersperse the options with the other arguments.
  56
  57    As `getopt' works, it permutes the elements of ARGV so that,
  58    when it is done, all the options precede everything else.  Thus
  59    all application programs are extended to handle flexible argument order.
  60
  61    Setting the environment variable POSIXLY_CORRECT disables permutation.
  62    Then the behavior is completely standard.
  63
  64    GNU application programs can use a third alternative mode in which
  65    they can distinguish the relative order of options and other arguments.  */
  66
  67 #include "getopt.h"
  68
  69 /* For communication from `getopt' to the caller.
  70    When `getopt' finds an option that takes an argument,
  71    the argument value is returned here.
  72    Also, when `ordering' is RETURN_IN_ORDER,
  73    each non-option ARGV-element is returned here.  */
  74
  75 char *optarg = NULL;
  76
  77 /* Index in ARGV of the next element to be scanned.
  78    This is used for communication to and from the caller
  79    and for communication between successive calls to `getopt'.
  80
  81    On entry to `getopt', zero means this is the first call; initialize.
  82
  83    When `getopt' returns EOF, this is the index of the first of the
  84    non-option elements that the caller should itself scan.
  85
  86    Otherwise, `optind' communicates from one call to the next
  87    how much of ARGV has been scanned so far.  */
  88
  89 /* XXX 1003.2 says this must be 1 before any call.  */
  90 int optind = 0;
  91
  92 /* The next char to be scanned in the option-element
  93    in which the last option character we returned was found.
  94    This allows us to pick up the scan where we left off.
  95
  96    If this is zero, or a null string, it means resume the scan
  97    by advancing to the next ARGV-element.  */
  98
  99 static char *nextchar;
 100
 101 /* Callers store zero here to inhibit the error message
 102    for unrecognized options.  */
 103
 104 int opterr = 1;
 105
 106 /* Set to an option character which was unrecognized.
 107    This must be initialized on some systems to avoid linking in the
 108    system's own getopt implementation.  */
 109
 110 int optopt = '?';
 111
 112 /* Describe how to deal with options that follow non-option ARGV-elements.
 113
 114    If the caller did not specify anything,
 115    the default is REQUIRE_ORDER if the environment variable
 116    POSIXLY_CORRECT is defined, PERMUTE otherwise.
 117
 118    REQUIRE_ORDER means don't recognize them as options;
 119    stop option processing when the first non-option is seen.
 120    This is what Unix does.
 121    This mode of operation is selected by either setting the environment
 122    variable POSIXLY_CORRECT, or using `+' as the first character
 123    of the list of option characters.
 124
 125    PERMUTE is the default.  We permute the contents of ARGV as we scan,
 126    so that eventually all the non-options are at the end.  This allows options
 127    to be given in any order, even with programs that were not written to
 128    expect this.
 129
 130    RETURN_IN_ORDER is an option available to programs that were written
 131    to expect options and other ARGV-elements in any order and that care about
 132    the ordering of the two.  We describe each non-option ARGV-element
 133    as if it were the argument of an option with character code 1.
 134    Using `-' as the first character of the list of option characters
 135    selects this mode of operation.
 136
 137    The special argument `--' forces an end of option-scanning regardless
 138    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
 139    `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
 140
 141 static enum
 142 {
 143   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
 144 } ordering;
 145
 146 /* Value of POSIXLY_CORRECT environment variable.  */
 147 static char *posixly_correct;
 148 \f
 149 #if defined (__GNU_LIBRARY__) || defined (__sgi)
 150 /* We want to avoid inclusion of string.h with non-GNU libraries
 151    because there are many ways it can cause trouble.
 152    On some systems, it contains special magic macros that don't work
 153    in GCC.  */
 154 #include <string.h>
 155 #define my_index        strchr
 156 #else
 157
 158 /* Avoid depending on library functions or files
 159    whose names are inconsistent.  */
 160
 161 char *getenv ();
 162
 163 static char *
 164 my_index (str, chr)
 165      const char *str;
 166      int chr;
 167 {
 168   while (*str)
 169     {
 170       if (*str == chr)
 171         return (char *) str;
 172       str++;
 173     }
 174   return 0;
 175 }
 176
 177 /* If using GCC, we can safely declare strlen this way.
 178    If not using GCC, it is ok not to declare it.  */
 179 #ifdef __GNUC__
 180 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
 181    That was relevant to code that was here before.  */
 182 #if !defined (__STDC__) || !__STDC__
 183 /* gcc with -traditional declares the built-in strlen to return int,
 184    and has done so at least since version 2.4.5. -- rms.  */
 185 extern int strlen (const char *);
 186 #endif /* not __STDC__ */
 187 #endif /* __GNUC__ */
 188
 189 #endif /* not __GNU_LIBRARY__ */
 190 \f
 191 /* Handle permutation of arguments.  */
 192
 193 /* Describe the part of ARGV that contains non-options that have
 194    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
 195    `last_nonopt' is the index after the last of them.  */
 196
 197 static int first_nonopt;
 198 static int last_nonopt;
 199
 200 /* Exchange two adjacent subsequences of ARGV.
 201    One subsequence is elements [first_nonopt,last_nonopt)
 202    which contains all the non-options that have been skipped so far.
 203    The other is elements [last_nonopt,optind), which contains all
 204    the options processed since those non-options were skipped.
 205
 206    `first_nonopt' and `last_nonopt' are relocated so that they describe
 207    the new indices of the non-options in ARGV after they are moved.  */
 208
 209 static void
 210 exchange (argv)
 211      char **argv;
 212 {
 213   int bottom = first_nonopt;
 214   int middle = last_nonopt;
 215   int top = optind;
 216   char *tem;
 217
 218   /* Exchange the shorter segment with the far end of the longer segment.
 219      That puts the shorter segment into the right place.
 220      It leaves the longer segment in the right place overall,
 221      but it consists of two parts that need to be swapped next.  */
 222
 223   while (top > middle && middle > bottom)
 224     {
 225       if (top - middle > middle - bottom)
 226         {
 227           /* Bottom segment is the short one.  */
 228           int len = middle - bottom;
 229           register int i;
 230
 231           /* Swap it with the top part of the top segment.  */
 232           for (i = 0; i < len; i++)
 233             {
 234               tem = argv[bottom + i];
 235               argv[bottom + i] = argv[top - (middle - bottom) + i];
 236               argv[top - (middle - bottom) + i] = tem;
 237             }
 238           /* Exclude the moved bottom segment from further swapping.  */
 239           top -= len;
 240         }
 241       else
 242         {
 243           /* Top segment is the short one.  */
 244           int len = top - middle;
 245           register int i;
 246
 247           /* Swap it with the bottom part of the bottom segment.  */
 248           for (i = 0; i < len; i++)
 249             {
 250               tem = argv[bottom + i];
 251               argv[bottom + i] = argv[middle + i];
 252               argv[middle + i] = tem;
 253             }
 254           /* Exclude the moved top segment from further swapping.  */
 255           bottom += len;
 256         }
 257     }
 258
 259   /* Update records for the slots the non-options now occupy.  */
 260
 261   first_nonopt += (optind - last_nonopt);
 262   last_nonopt = optind;
 263 }
 264
 265 /* Initialize the internal data when the first call is made.  */
 266
 267 static const char *
 268 _getopt_initialize (optstring)
 269      const char *optstring;
 270 {
 271   /* Start processing options with ARGV-element 1 (since ARGV-element 0
 272      is the program name); the sequence of previously skipped
 273      non-option ARGV-elements is empty.  */
 274
 275   first_nonopt = last_nonopt = optind = 1;
 276
 277   nextchar = NULL;
 278
 279   posixly_correct = getenv ("POSIXLY_CORRECT");
 280
 281   /* Determine how to handle the ordering of options and nonoptions.  */
 282
 283   if (optstring[0] == '-')
 284     {
 285       ordering = RETURN_IN_ORDER;
 286       ++optstring;
 287     }
 288   else if (optstring[0] == '+')
 289     {
 290       ordering = REQUIRE_ORDER;
 291       ++optstring;
 292     }
 293   else if (posixly_correct != NULL)
 294     ordering = REQUIRE_ORDER;
 295   else
 296     ordering = PERMUTE;
 297
 298   return optstring;
 299 }
 300 \f
 301 /* Scan elements of ARGV (whose length is ARGC) for option characters
 302    given in OPTSTRING.
 303
 304    If an element of ARGV starts with '-', and is not exactly "-" or "--",
 305    then it is an option element.  The characters of this element
 306    (aside from the initial '-') are option characters.  If `getopt'
 307    is called repeatedly, it returns successively each of the option characters
 308    from each of the option elements.
 309
 310    If `getopt' finds another option character, it returns that character,
 311    updating `optind' and `nextchar' so that the next call to `getopt' can
 312    resume the scan with the following option character or ARGV-element.
 313
 314    If there are no more option characters, `getopt' returns `EOF'.
 315    Then `optind' is the index in ARGV of the first ARGV-element
 316    that is not an option.  (The ARGV-elements have been permuted
 317    so that those that are not options now come last.)
 318
 319    OPTSTRING is a string containing the legitimate option characters.
 320    If an option character is seen that is not listed in OPTSTRING,
 321    return '?' after printing an error message.  If you set `opterr' to
 322    zero, the error message is suppressed but we still return '?'.
 323
 324    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
 325    so the following text in the same ARGV-element, or the text of the following
 326    ARGV-element, is returned in `optarg'.  Two colons mean an option that
 327    wants an optional arg; if there is text in the current ARGV-element,
 328    it is returned in `optarg', otherwise `optarg' is set to zero.
 329
 330    If OPTSTRING starts with `-' or `+', it requests different methods of
 331    handling the non-option ARGV-elements.
 332    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
 333
 334    Long-named options begin with `--' instead of `-'.
 335    Their names may be abbreviated as long as the abbreviation is unique
 336    or is an exact match for some defined option.  If they have an
 337    argument, it follows the option name in the same ARGV-element, separated
 338    from the option name by a `=', or else the in next ARGV-element.
 339    When `getopt' finds a long-named option, it returns 0 if that option's
 340    `flag' field is nonzero, the value of the option's `val' field
 341    if the `flag' field is zero.
 342
 343    The elements of ARGV aren't really const, because we permute them.
 344    But we pretend they're const in the prototype to be compatible
 345    with other systems.
 346
 347    LONGOPTS is a vector of `struct option' terminated by an
 348    element containing a name which is zero.
 349
 350    LONGIND returns the index in LONGOPT of the long-named option found.
 351    It is only valid when a long-named option has been found by the most
 352    recent call.
 353
 354    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
 355    long-named options.  */
 356
 357 int
 358 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
 359      int argc;
 360      char *const *argv;
 361      const char *optstring;
 362      const struct option *longopts;
 363      int *longind;
 364      int long_only;
 365 {
 366   optarg = NULL;
 367
 368   if (optind == 0)
 369     optstring = _getopt_initialize (optstring);
 370
 371   if (nextchar == NULL || *nextchar == '\0')
 372     {
 373       /* Advance to the next ARGV-element.  */
 374
 375       if (ordering == PERMUTE)
 376         {
 377           /* If we have just processed some options following some non-options,
 378              exchange them so that the options come first.  */
 379
 380           if (first_nonopt != last_nonopt && last_nonopt != optind)
 381             exchange ((char **) argv);
 382           else if (last_nonopt != optind)
 383             first_nonopt = optind;
 384
 385           /* Skip any additional non-options
 386              and extend the range of non-options previously skipped.  */
 387
 388           while (optind < argc
 389                  && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
 390             optind++;
 391           last_nonopt = optind;
 392         }
 393
 394       /* The special ARGV-element `--' means premature end of options.
 395          Skip it like a null option,
 396          then exchange with previous non-options as if it were an option,
 397          then skip everything else like a non-option.  */
 398
 399       if (optind != argc && !strcmp (argv[optind], "--"))
 400         {
 401           optind++;
 402
 403           if (first_nonopt != last_nonopt && last_nonopt != optind)
 404             exchange ((char **) argv);
 405           else if (first_nonopt == last_nonopt)
 406             first_nonopt = optind;
 407           last_nonopt = argc;
 408
 409           optind = argc;
 410         }
 411
 412       /* If we have done all the ARGV-elements, stop the scan
 413          and back over any non-options that we skipped and permuted.  */
 414
 415       if (optind == argc)
 416         {
 417           /* Set the next-arg-index to point at the non-options
 418              that we previously skipped, so the caller will digest them.  */
 419           if (first_nonopt != last_nonopt)
 420             optind = first_nonopt;
 421           return EOF;
 422         }
 423
 424       /* If we have come to a non-option and did not permute it,
 425          either stop the scan or describe it to the caller and pass it by.  */
 426
 427       if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
 428         {
 429           if (ordering == REQUIRE_ORDER)
 430             return EOF;
 431           optarg = argv[optind++];
 432           return 1;
 433         }
 434
 435       /* We have found another option-ARGV-element.
 436          Skip the initial punctuation.  */
 437
 438       nextchar = (argv[optind] + 1
 439                   + (longopts != NULL && argv[optind][1] == '-'));
 440     }
 441
 442   /* Decode the current option-ARGV-element.  */
 443
 444   /* Check whether the ARGV-element is a long option.
 445
 446      If long_only and the ARGV-element has the form "-f", where f is
 447      a valid short option, don't consider it an abbreviated form of
 448      a long option that starts with f.  Otherwise there would be no
 449      way to give the -f short option.
 450
 451      On the other hand, if there's a long option "fubar" and
 452      the ARGV-element is "-fu", do consider that an abbreviation of
 453      the long option, just like "--fu", and not "-f" with arg "u".
 454
 455      This distinction seems to be the most useful approach.  */
 456
 457   if (longopts != NULL
 458       && (argv[optind][1] == '-'
 459           || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
 460     {
 461       char *nameend;
 462       const struct option *p;
 463       const struct option *pfound = NULL;
 464       int exact = 0;
 465       int ambig = 0;
 466       int indfound;
 467       int option_index;
 468
 469       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
 470         /* Do nothing.  */ ;
 471
 472 #ifdef lint
 473       /* Suppress `used before initialized' warning.  */
 474       indfound = 0;
 475 #endif
 476
 477       /* Test all long options for either exact match
 478          or abbreviated matches.  */
 479       for (p = longopts, option_index = 0; p->name; p++, option_index++)
 480         if (!strncmp (p->name, nextchar, nameend - nextchar))
 481           {
 482             if (nameend - nextchar == strlen (p->name))
 483               {
 484                 /* Exact match found.  */
 485                 pfound = p;
 486                 indfound = option_index;
 487                 exact = 1;
 488                 break;
 489               }
 490             else if (pfound == NULL)
 491               {
 492                 /* First nonexact match found.  */
 493                 pfound = p;
 494                 indfound = option_index;
 495               }
 496             else
 497               /* Second or later nonexact match found.  */
 498               ambig = 1;
 499           }
 500
 501       if (ambig && !exact)
 502         {
 503           if (opterr)
 504             fprintf (stderr, "%s: option `%s' is ambiguous\n",
 505                      argv[0], argv[optind]);
 506           nextchar += strlen (nextchar);
 507           optind++;
 508           return '?';
 509         }
 510
 511       if (pfound != NULL)
 512         {
 513           option_index = indfound;
 514           optind++;
 515           if (*nameend)
 516             {
 517               /* Don't test has_arg with >, because some C compilers don't
 518                  allow it to be used on enums.  */
 519               if (pfound->has_arg)
 520                 optarg = nameend + 1;
 521               else
 522                 {
 523                   if (opterr)
 524                     {
 525                       if (argv[optind - 1][1] == '-')
 526                         /* --option */
 527                         fprintf (stderr,
 528                                  "%s: option `--%s' doesn't allow an argument\n",
 529                                  argv[0], pfound->name);
 530                       else
 531                         /* +option or -option */
 532                         fprintf (stderr,
 533                              "%s: option `%c%s' doesn't allow an argument\n",
 534                              argv[0], argv[optind - 1][0], pfound->name);
 535                     }
 536                   nextchar += strlen (nextchar);
 537                   return '?';
 538                 }
 539             }
 540           else if (pfound->has_arg == 1)
 541             {
 542               if (optind < argc)
 543                 optarg = argv[optind++];
 544               else
 545                 {
 546                   if (opterr)
 547                     fprintf (stderr, "%s: option `%s' requires an argument\n",
 548                              argv[0], argv[optind - 1]);
 549                   nextchar += strlen (nextchar);
 550                   return optstring[0] == ':' ? ':' : '?';
 551                 }
 552             }
 553           nextchar += strlen (nextchar);
 554           if (longind != NULL)
 555             *longind = option_index;
 556           if (pfound->flag)
 557             {
 558               *(pfound->flag) = pfound->val;
 559               return 0;
 560             }
 561           return pfound->val;
 562         }
 563
 564       /* Can't find it as a long option.  If this is not getopt_long_only,
 565          or the option starts with '--' or is not a valid short
 566          option, then it's an error.
 567          Otherwise interpret it as a short option.  */
 568       if (!long_only || argv[optind][1] == '-'
 569           || my_index (optstring, *nextchar) == NULL)
 570         {
 571           if (opterr)
 572             {
 573               if (argv[optind][1] == '-')
 574                 /* --option */
 575                 fprintf (stderr, "%s: unrecognized option `--%s'\n",
 576                          argv[0], nextchar);
 577               else
 578                 /* +option or -option */
 579                 fprintf (stderr, "%s: unrecognized option `%c%s'\n",
 580                          argv[0], argv[optind][0], nextchar);
 581             }
 582           nextchar = (char *) "";
 583           optind++;
 584           return '?';
 585         }
 586     }
 587
 588   /* Look at and handle the next short option-character.  */
 589
 590   {
 591     char c = *nextchar++;
 592     char *temp = my_index (optstring, c);
 593
 594     /* Increment `optind' when we start to process its last character.  */
 595     if (*nextchar == '\0')
 596       ++optind;
 597
 598     if (temp == NULL || c == ':')
 599       {
 600         if (opterr)
 601           {
 602             if (posixly_correct)
 603               /* 1003.2 specifies the format of this message.  */
 604               fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
 605             else
 606               fprintf (stderr, "%s: invalid option -- %c\n", argv[0], c);
 607           }
 608         optopt = c;
 609         return '?';
 610       }
 611     if (temp[1] == ':')
 612       {
 613         if (temp[2] == ':')
 614           {
 615             /* This is an option that accepts an argument optionally.  */
 616             if (*nextchar != '\0')
 617               {
 618                 optarg = nextchar;
 619                 optind++;
 620               }
 621             else
 622               optarg = NULL;
 623             nextchar = NULL;
 624           }
 625         else
 626           {
 627             /* This is an option that requires an argument.  */
 628             if (*nextchar != '\0')
 629               {
 630                 optarg = nextchar;
 631                 /* If we end this ARGV-element by taking the rest as an arg,
 632                    we must advance to the next element now.  */
 633                 optind++;
 634               }
 635             else if (optind == argc)
 636               {
 637                 if (opterr)
 638                   {
 639                     /* 1003.2 specifies the format of this message.  */
 640                     fprintf (stderr, "%s: option requires an argument -- %c\n",
 641                              argv[0], c);
 642                   }
 643                 optopt = c;
 644                 if (optstring[0] == ':')
 645                   c = ':';
 646                 else
 647                   c = '?';
 648               }
 649             else
 650               /* We already incremented `optind' once;
 651                  increment it again when taking next ARGV-elt as argument.  */
 652               optarg = argv[optind++];
 653             nextchar = NULL;
 654           }
 655       }
 656     return c;
 657   }
 658 }
 659
 660 int
 661 getopt (argc, argv, optstring)
 662      int argc;
 663      char *const *argv;
 664      const char *optstring;
 665 {
 666   return _getopt_internal (argc, argv, optstring,
 667                            (const struct option *) 0,
 668                            (int *) 0,
 669                            0);
 670 }
 671
 672 #endif  /* _LIBC or not __GNU_LIBRARY__.  */
 673 \f
 674 #ifdef TEST
 675
 676 /* Compile with -DTEST to make an executable for use in testing
 677    the above definition of `getopt'.  */
 678
 679 int
 680 main (argc, argv)
 681      int argc;
 682      char **argv;
 683 {
 684   int c;
 685   int digit_optind = 0;
 686
 687   while (1)
 688     {
 689       int this_option_optind = optind ? optind : 1;
 690
 691       c = getopt (argc, argv, "abc:d:0123456789");
 692       if (c == EOF)
 693         break;
 694
 695       switch (c)
 696         {
 697         case '0':
 698         case '1':
 699         case '2':
 700         case '3':
 701         case '4':
 702         case '5':
 703         case '6':
 704         case '7':
 705         case '8':
 706         case '9':
 707           if (digit_optind != 0 && digit_optind != this_option_optind)
 708             printf ("digits occur in two different argv-elements.\n");
 709           digit_optind = this_option_optind;
 710           printf ("option %c\n", c);
 711           break;
 712
 713         case 'a':
 714           printf ("option a\n");
 715           break;
 716
 717         case 'b':
 718           printf ("option b\n");
 719           break;
 720
 721         case 'c':
 722           printf ("option c with value `%s'\n", optarg);
 723           break;
 724
 725         case '?':
 726           break;
 727
 728         default:
 729           printf ("?? getopt returned character code 0%o ??\n", c);
 730         }
 731     }
 732
 733   if (optind < argc)
 734     {
 735       printf ("non-option ARGV-elements: ");
 736       while (optind < argc)
 737         printf ("%s ", argv[optind++]);
 738       printf ("\n");
 739     }
 740
 741   exit (0);
 742 }
 743
 744 #endif /* TEST */