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