libextractor

GNU libextractor
Log | Files | Refs | Submodules | README | LICENSE

getopt.c (31979B)


      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 Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
      7     Free Software Foundation, Inc.
      8 
      9 NOTE: The canonical source of this file is maintained with the GNU C Library.
     10 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
     11 
     12 This program is free software; you can redistribute it and/or modify it
     13 under the terms of the GNU General Public License as published by the
     14 Free Software Foundation; either version 2, or (at your option) any
     15 later version.
     16 
     17 This program is distributed in the hope that it will be useful,
     18 but WITHOUT ANY WARRANTY; without even the implied warranty of
     19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     20 GNU General Public License for more details.
     21 
     22 You should have received a copy of the GNU General Public License
     23 along with this program; if not, write to the Free Software
     24 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
     25 USA.  */
     26 
     27 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
     28    Ditto for AIX 3.2 and <stdlib.h>.  */
     29 #ifndef _NO_PROTO
     30 #define _NO_PROTO
     31 #endif
     32 
     33 #include "config.h"
     34 
     35 #if ! defined (__STDC__) || ! __STDC__
     36 /* This is a separate conditional since some stdc systems
     37    reject `defined (const)'.  */
     38 #ifndef const
     39 #define const
     40 #endif
     41 #endif
     42 
     43 #include <stdio.h>
     44 
     45 /* Comment out all this code if we are using the GNU C Library, and are not
     46    actually compiling the library itself.  This code is part of the GNU C
     47    Library, but also included in many other GNU distributions.  Compiling
     48    and linking in this code is a waste when using the GNU C library
     49    (especially if it is a shared library).  Rather than having every GNU
     50    program understand `configure --with-gnu-libc' and omit the object files,
     51    it is simpler to just do this in the source for each such file.  */
     52 
     53 #define GETOPT_INTERFACE_VERSION 2
     54 #if ! defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
     55 #include <gnu-versions.h>
     56 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
     57 #define ELIDE_CODE
     58 #endif
     59 #endif
     60 
     61 #ifndef ELIDE_CODE
     62 
     63 
     64 /* This needs to come after some library #include
     65    to get __GNU_LIBRARY__ defined.  */
     66 #ifdef  __GNU_LIBRARY__
     67 /* Don't include stdlib.h for non-GNU C libraries because some of them
     68    contain conflicting prototypes for getopt.  */
     69 #include <stdlib.h>
     70 #include <unistd.h>
     71 #endif /* GNU C library.  */
     72 
     73 #ifdef VMS
     74 #include <unixlib.h>
     75 #endif
     76 #if HAVE_STRING_H
     77 #include <string.h>
     78 #endif
     79 
     80 #if defined (WIN32) && ! defined (__CYGWIN32__)
     81 /* It's not Unix, really.  See?  Capital letters.  */
     82 #include <windows.h>
     83 #define getpid() GetCurrentProcessId ()
     84 #endif
     85 
     86 #ifndef _
     87 /* This is for other GNU distributions with internationalized messages.
     88    When compiling libc, the _ macro is predefined.  */
     89 #ifdef NEVER_HAVE_LIBINTL_H
     90 # include <libintl.h>
     91 # define _(msgid) gettext (msgid)
     92 #else
     93 # define _(msgid) (msgid)
     94 #endif
     95 #endif
     96 
     97 /* This version of `getopt' appears to the caller like standard Unix `getopt'
     98    but it behaves differently for the user, since it allows the user
     99    to intersperse the options with the other arguments.
    100 
    101    As `getopt' works, it permutes the elements of ARGV so that,
    102    when it is done, all the options precede everything else.  Thus
    103    all application programs are extended to handle flexible argument order.
    104 
    105    Setting the environment variable POSIXLY_CORRECT disables permutation.
    106    Then the behavior is completely standard.
    107 
    108    GNU application programs can use a third alternative mode in which
    109    they can distinguish the relative order of options and other arguments.  */
    110 
    111 #include "getopt.h"
    112 
    113 /* For communication from `getopt' to the caller.
    114    When `getopt' finds an option that takes an argument,
    115    the argument value is returned here.
    116    Also, when `ordering' is RETURN_IN_ORDER,
    117    each non-option ARGV-element is returned here.  */
    118 
    119 char *optarg = NULL;
    120 
    121 /* Index in ARGV of the next element to be scanned.
    122    This is used for communication to and from the caller
    123    and for communication between successive calls to `getopt'.
    124 
    125    On entry to `getopt', zero means this is the first call; initialize.
    126 
    127    When `getopt' returns -1, this is the index of the first of the
    128    non-option elements that the caller should itself scan.
    129 
    130    Otherwise, `optind' communicates from one call to the next
    131    how much of ARGV has been scanned so far.  */
    132 
    133 /* 1003.2 says this must be 1 before any call.  */
    134 int optind = 1;
    135 
    136 /* Formerly, initialization of getopt depended on optind==0, which
    137    causes problems with re-calling getopt as programs generally don't
    138    know that. */
    139 
    140 int __getopt_initialized = 0;
    141 
    142 /* The next char to be scanned in the option-element
    143    in which the last option character we returned was found.
    144    This allows us to pick up the scan where we left off.
    145 
    146    If this is zero, or a null string, it means resume the scan
    147    by advancing to the next ARGV-element.  */
    148 
    149 static char *nextchar;
    150 
    151 /* Callers store zero here to inhibit the error message
    152    for unrecognized options.  */
    153 
    154 int opterr = 1;
    155 
    156 /* Set to an option character which was unrecognized.
    157    This must be initialized on some systems to avoid linking in the
    158    system's own getopt implementation.  */
    159 
    160 int optopt = '?';
    161 
    162 /* Describe how to deal with options that follow non-option ARGV-elements.
    163 
    164    If the caller did not specify anything,
    165    the default is REQUIRE_ORDER if the environment variable
    166    POSIXLY_CORRECT is defined, PERMUTE otherwise.
    167 
    168    REQUIRE_ORDER means don't recognize them as options;
    169    stop option processing when the first non-option is seen.
    170    This is what Unix does.
    171    This mode of operation is selected by either setting the environment
    172    variable POSIXLY_CORRECT, or using `+' as the first character
    173    of the list of option characters.
    174 
    175    PERMUTE is the default.  We permute the contents of ARGV as we scan,
    176    so that eventually all the non-options are at the end.  This allows options
    177    to be given in any order, even with programs that were not written to
    178    expect this.
    179 
    180    RETURN_IN_ORDER is an option available to programs that were written
    181    to expect options and other ARGV-elements in any order and that care about
    182    the ordering of the two.  We describe each non-option ARGV-element
    183    as if it were the argument of an option with character code 1.
    184    Using `-' as the first character of the list of option characters
    185    selects this mode of operation.
    186 
    187    The special argument `--' forces an end of option-scanning regardless
    188    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
    189    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
    190 
    191 static enum
    192 {
    193   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
    194 } ordering;
    195 
    196 /* Value of POSIXLY_CORRECT environment variable.  */
    197 static char *posixly_correct;
    198 
    199 #ifdef  __GNU_LIBRARY__
    200 /* We want to avoid inclusion of string.h with non-GNU libraries
    201    because there are many ways it can cause trouble.
    202    On some systems, it contains special magic macros that don't work
    203    in GCC.  */
    204 #include <string.h>
    205 #define my_index  strchr
    206 #else
    207 
    208 /* Avoid depending on library functions or files
    209    whose names are inconsistent.  */
    210 
    211 #include <stdlib.h>
    212 
    213 static char *
    214 my_index (const char *str, int chr)
    215 {
    216   while (*str)
    217   {
    218     if (*str == chr)
    219       return (char *) str;
    220     str++;
    221   }
    222   return 0;
    223 }
    224 
    225 
    226 /* If using GCC, we can safely declare strlen this way.
    227    If not using GCC, it is ok not to declare it.  */
    228 #ifdef __GNUC__
    229 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
    230    That was relevant to code that was here before.  */
    231 #if ! defined (__STDC__) || ! __STDC__
    232 /* gcc with -traditional declares the built-in strlen to return int,
    233    and has done so at least since version 2.4.5. -- rms.  */
    234 extern int strlen (const char *);
    235 
    236 #endif /* not __STDC__ */
    237 #if defined(__APPLE__)
    238 extern size_t strlen (const char *);
    239 
    240 #endif
    241 #endif /* __GNUC__ */
    242 
    243 #endif /* not __GNU_LIBRARY__ */
    244 
    245 /* Handle permutation of arguments.  */
    246 
    247 /* Describe the part of ARGV that contains non-options that have
    248    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
    249    `last_nonopt' is the index after the last of them.  */
    250 
    251 static int first_nonopt;
    252 static int last_nonopt;
    253 
    254 #ifdef _LIBC
    255 /* Bash 2.0 gives us an environment variable containing flags
    256    indicating ARGV elements that should not be considered arguments.  */
    257 
    258 /* Defined in getopt_init.c  */
    259 extern char *__getopt_nonoption_flags;
    260 
    261 static int nonoption_flags_max_len;
    262 static int nonoption_flags_len;
    263 
    264 static int original_argc;
    265 static char *const *original_argv;
    266 
    267 extern pid_t __libc_pid;
    268 
    269 /* Make sure the environment variable bash 2.0 puts in the environment
    270    is valid for the getopt call we must make sure that the ARGV passed
    271    to getopt is that one passed to the process.  */
    272 static void
    273 __attribute__ ((unused))
    274 store_args_and_env (int argc, char *const *argv)
    275 {
    276   /* XXX This is no good solution.  We should rather copy the args so
    277      that we can compare them later.  But we must not use malloc(3).  */
    278   original_argc = argc;
    279   original_argv = argv;
    280 }
    281 
    282 
    283 text_set_element (__libc_subinit, store_args_and_env);
    284 
    285 # define SWAP_FLAGS(ch1, ch2) \
    286         if (nonoption_flags_len > 0)                  \
    287         {                       \
    288           char __tmp = __getopt_nonoption_flags[ch1];           \
    289           __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];        \
    290           __getopt_nonoption_flags[ch2] = __tmp;              \
    291         }
    292 #else /* !_LIBC */
    293 # define SWAP_FLAGS(ch1, ch2)
    294 #endif /* _LIBC */
    295 
    296 /* Exchange two adjacent subsequences of ARGV.
    297    One subsequence is elements [first_nonopt,last_nonopt)
    298    which contains all the non-options that have been skipped so far.
    299    The other is elements [last_nonopt,optind), which contains all
    300    the options processed since those non-options were skipped.
    301 
    302    `first_nonopt' and `last_nonopt' are relocated so that they describe
    303    the new indices of the non-options in ARGV after they are moved.  */
    304 
    305 #if defined (__STDC__) && __STDC__
    306 static void exchange (char **);
    307 
    308 #endif
    309 
    310 static void
    311 exchange (char **argv)
    312 {
    313   int bottom = first_nonopt;
    314   int middle = last_nonopt;
    315   int top = optind;
    316   char *tem;
    317 
    318   /* Exchange the shorter segment with the far end of the longer segment.
    319      That puts the shorter segment into the right place.
    320      It leaves the longer segment in the right place overall,
    321      but it consists of two parts that need to be swapped next.  */
    322 
    323 #ifdef _LIBC
    324   /* First make sure the handling of the `__getopt_nonoption_flags'
    325      string can work normally.  Our top argument must be in the range
    326      of the string.  */
    327   if ((nonoption_flags_len > 0) && (top >= nonoption_flags_max_len))
    328   {
    329     /* We must extend the array.  The user plays games with us and
    330        presents new arguments.  */
    331     char *new_str = malloc (top + 1);
    332     if (new_str == NULL)
    333       nonoption_flags_len = nonoption_flags_max_len = 0;
    334     else
    335     {
    336       memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
    337       memset (&new_str[nonoption_flags_max_len], '\0',
    338               top + 1 - nonoption_flags_max_len);
    339       nonoption_flags_max_len = top + 1;
    340       __getopt_nonoption_flags = new_str;
    341     }
    342   }
    343 #endif
    344 
    345   while (top > middle && middle > bottom)
    346   {
    347     if (top - middle > middle - bottom)
    348     {
    349       /* Bottom segment is the short one.  */
    350       int len = middle - bottom;
    351       register int i;
    352 
    353       /* Swap it with the top part of the top segment.  */
    354       for (i = 0; i < len; i++)
    355       {
    356         tem = argv[bottom + i];
    357         argv[bottom + i] = argv[top - (middle - bottom) + i];
    358         argv[top - (middle - bottom) + i] = tem;
    359         SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
    360       }
    361       /* Exclude the moved bottom segment from further swapping.  */
    362       top -= len;
    363     }
    364     else
    365     {
    366       /* Top segment is the short one.  */
    367       int len = top - middle;
    368       register int i;
    369 
    370       /* Swap it with the bottom part of the bottom segment.  */
    371       for (i = 0; i < len; i++)
    372       {
    373         tem = argv[bottom + i];
    374         argv[bottom + i] = argv[middle + i];
    375         argv[middle + i] = tem;
    376         SWAP_FLAGS (bottom + i, middle + i);
    377       }
    378       /* Exclude the moved top segment from further swapping.  */
    379       bottom += len;
    380     }
    381   }
    382 
    383   /* Update records for the slots the non-options now occupy.  */
    384 
    385   first_nonopt += (optind - last_nonopt);
    386   last_nonopt = optind;
    387 }
    388 
    389 
    390 /* Initialize the internal data when the first call is made.  */
    391 
    392 #if defined (__STDC__) && __STDC__
    393 static const char *_getopt_initialize (int, char *const *, const char *);
    394 
    395 #endif
    396 static const char *
    397 _getopt_initialize (int argc, char *const *argv, const char *optstring)
    398 {
    399   /* Start processing options with ARGV-element 1 (since ARGV-element 0
    400      is the program name); the sequence of previously skipped
    401      non-option ARGV-elements is empty.  */
    402 
    403   first_nonopt = last_nonopt = optind;
    404 
    405   nextchar = NULL;
    406 
    407   posixly_correct = getenv ("POSIXLY_CORRECT");
    408 
    409   /* Determine how to handle the ordering of options and nonoptions.  */
    410 
    411   if (optstring[0] == '-')
    412   {
    413     ordering = RETURN_IN_ORDER;
    414     ++optstring;
    415   }
    416   else if (optstring[0] == '+')
    417   {
    418     ordering = REQUIRE_ORDER;
    419     ++optstring;
    420   }
    421   else if (posixly_correct != NULL)
    422     ordering = REQUIRE_ORDER;
    423   else
    424     ordering = PERMUTE;
    425 
    426 #ifdef _LIBC
    427   if ((posixly_correct == NULL)
    428       && (argc == original_argc) && (argv == original_argv))
    429   {
    430     if (nonoption_flags_max_len == 0)
    431     {
    432       if ((__getopt_nonoption_flags == NULL)
    433           || (__getopt_nonoption_flags[0] == '\0') )
    434         nonoption_flags_max_len = -1;
    435       else
    436       {
    437         const char *orig_str = __getopt_nonoption_flags;
    438         int len = nonoption_flags_max_len = strlen (orig_str);
    439         if (nonoption_flags_max_len < argc)
    440           nonoption_flags_max_len = argc;
    441         __getopt_nonoption_flags =
    442           (char *) malloc (nonoption_flags_max_len);
    443         if (__getopt_nonoption_flags == NULL)
    444           nonoption_flags_max_len = -1;
    445         else
    446         {
    447           memcpy (__getopt_nonoption_flags, orig_str, len);
    448           memset (&__getopt_nonoption_flags[len], '\0',
    449                   nonoption_flags_max_len - len);
    450         }
    451       }
    452     }
    453     nonoption_flags_len = nonoption_flags_max_len;
    454   }
    455   else
    456     nonoption_flags_len = 0;
    457 #endif
    458 
    459   return optstring;
    460 }
    461 
    462 
    463 /* Scan elements of ARGV (whose length is ARGC) for option characters
    464    given in OPTSTRING.
    465 
    466    If an element of ARGV starts with '-', and is not exactly "-" or "--",
    467    then it is an option element.  The characters of this element
    468    (aside from the initial '-') are option characters.  If `getopt'
    469    is called repeatedly, it returns successively each of the option characters
    470    from each of the option elements.
    471 
    472    If `getopt' finds another option character, it returns that character,
    473    updating `optind' and `nextchar' so that the next call to `getopt' can
    474    resume the scan with the following option character or ARGV-element.
    475 
    476    If there are no more option characters, `getopt' returns -1.
    477    Then `optind' is the index in ARGV of the first ARGV-element
    478    that is not an option.  (The ARGV-elements have been permuted
    479    so that those that are not options now come last.)
    480 
    481    OPTSTRING is a string containing the legitimate option characters.
    482    If an option character is seen that is not listed in OPTSTRING,
    483    return '?' after printing an error message.  If you set `opterr' to
    484    zero, the error message is suppressed but we still return '?'.
    485 
    486    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
    487    so the following text in the same ARGV-element, or the text of the following
    488    ARGV-element, is returned in `optarg'.  Two colons mean an option that
    489    wants an optional arg; if there is text in the current ARGV-element,
    490    it is returned in `optarg', otherwise `optarg' is set to zero.
    491 
    492    If OPTSTRING starts with `-' or `+', it requests different methods of
    493    handling the non-option ARGV-elements.
    494    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
    495 
    496    Long-named options begin with `--' instead of `-'.
    497    Their names may be abbreviated as long as the abbreviation is unique
    498    or is an exact match for some defined option.  If they have an
    499    argument, it follows the option name in the same ARGV-element, separated
    500    from the option name by a `=', or else the in next ARGV-element.
    501    When `getopt' finds a long-named option, it returns 0 if that option's
    502    `flag' field is nonzero, the value of the option's `val' field
    503    if the `flag' field is zero.
    504 
    505    The elements of ARGV aren't really const, because we permute them.
    506    But we pretend they're const in the prototype to be compatible
    507    with other systems.
    508 
    509    LONGOPTS is a vector of `struct option' terminated by an
    510    element containing a name which is zero.
    511 
    512    LONGIND returns the index in LONGOPT of the long-named option found.
    513    It is only valid when a long-named option has been found by the most
    514    recent call.
    515 
    516    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
    517    long-named options.  */
    518 
    519 int
    520 _getopt_internal (int argc, char *const *argv, const char *optstring,
    521                   const struct option *longopts, int *longind, int long_only)
    522 {
    523   optarg = NULL;
    524 
    525   if ((optind == 0) || ! __getopt_initialized)
    526   {
    527     if (optind == 0)
    528       optind = 1; /* Don't scan ARGV[0], the program name.  */
    529     optstring = _getopt_initialize (argc, argv, optstring);
    530     __getopt_initialized = 1;
    531   }
    532 
    533   /* Test whether ARGV[optind] points to a non-option argument.
    534      Either it does not have option syntax, or there is an environment flag
    535      from the shell indicating it is not an option.  The later information
    536      is only used when the used in the GNU libc.  */
    537 #ifdef _LIBC
    538 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
    539                      || (optind < nonoption_flags_len           \
    540                          && __getopt_nonoption_flags[optind] == '1'))
    541 #else
    542 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
    543 #endif
    544 
    545   if ((nextchar == NULL) || (*nextchar == '\0'))
    546   {
    547     /* Advance to the next ARGV-element.  */
    548 
    549     /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
    550        moved back by the user (who may also have changed the arguments).  */
    551     if (last_nonopt > optind)
    552       last_nonopt = optind;
    553     if (first_nonopt > optind)
    554       first_nonopt = optind;
    555 
    556     if (ordering == PERMUTE)
    557     {
    558       /* If we have just processed some options following some non-options,
    559          exchange them so that the options come first.  */
    560 
    561       if ((first_nonopt != last_nonopt) && (last_nonopt != optind) )
    562         exchange ((char **) argv);
    563       else if (last_nonopt != optind)
    564         first_nonopt = optind;
    565 
    566       /* Skip any additional non-options
    567          and extend the range of non-options previously skipped.  */
    568 
    569       while (optind < argc && NONOPTION_P)
    570         optind++;
    571       last_nonopt = optind;
    572     }
    573 
    574     /* The special ARGV-element `--' means premature end of options.
    575        Skip it like a null option,
    576        then exchange with previous non-options as if it were an option,
    577        then skip everything else like a non-option.  */
    578 
    579     if ((optind != argc) && ! strcmp (argv[optind], "--"))
    580     {
    581       optind++;
    582 
    583       if ((first_nonopt != last_nonopt) && (last_nonopt != optind) )
    584         exchange ((char **) argv);
    585       else if (first_nonopt == last_nonopt)
    586         first_nonopt = optind;
    587       last_nonopt = argc;
    588 
    589       optind = argc;
    590     }
    591 
    592     /* If we have done all the ARGV-elements, stop the scan
    593        and back over any non-options that we skipped and permuted.  */
    594 
    595     if (optind == argc)
    596     {
    597       /* Set the next-arg-index to point at the non-options
    598          that we previously skipped, so the caller will digest them.  */
    599       if (first_nonopt != last_nonopt)
    600         optind = first_nonopt;
    601       return -1;
    602     }
    603 
    604     /* If we have come to a non-option and did not permute it,
    605        either stop the scan or describe it to the caller and pass it by.  */
    606 
    607     if (NONOPTION_P)
    608     {
    609       if (ordering == REQUIRE_ORDER)
    610         return -1;
    611       optarg = argv[optind++];
    612       return 1;
    613     }
    614 
    615     /* We have found another option-ARGV-element.
    616        Skip the initial punctuation.  */
    617 
    618     nextchar = (argv[optind] + 1
    619                 + (longopts != NULL && argv[optind][1] == '-'));
    620   }
    621 
    622   /* Decode the current option-ARGV-element.  */
    623 
    624   /* Check whether the ARGV-element is a long option.
    625 
    626      If long_only and the ARGV-element has the form "-f", where f is
    627      a valid short option, don't consider it an abbreviated form of
    628      a long option that starts with f.  Otherwise there would be no
    629      way to give the -f short option.
    630 
    631      On the other hand, if there's a long option "fubar" and
    632      the ARGV-element is "-fu", do consider that an abbreviation of
    633      the long option, just like "--fu", and not "-f" with arg "u".
    634 
    635      This distinction seems to be the most useful approach.  */
    636 
    637   if ((longopts != NULL)
    638       && ((argv[optind][1] == '-')
    639           || (long_only
    640               && (argv[optind][2]
    641                   || ! my_index (optstring, argv[optind][1])))))
    642   {
    643     char *nameend;
    644     const struct option *p;
    645     const struct option *pfound = NULL;
    646     int exact = 0;
    647     int ambig = 0;
    648     int indfound = -1;
    649     int option_index;
    650 
    651     for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
    652       /* Do nothing.  */;
    653 
    654     /* Test all long options for either exact match
    655        or abbreviated matches.  */
    656     for (p = longopts, option_index = 0; p->name; p++, option_index++)
    657       if (! strncmp (p->name, nextchar, nameend - nextchar))
    658       {
    659         if ((unsigned int) (nameend - nextchar)
    660             == (unsigned int) strlen (p->name))
    661         {
    662           /* Exact match found.  */
    663           pfound = p;
    664           indfound = option_index;
    665           exact = 1;
    666           break;
    667         }
    668         else if (pfound == NULL)
    669         {
    670           /* First nonexact match found.  */
    671           pfound = p;
    672           indfound = option_index;
    673         }
    674         else
    675           /* Second or later nonexact match found.  */
    676           ambig = 1;
    677       }
    678 
    679     if (ambig && ! exact)
    680     {
    681       if (opterr)
    682         fprintf (stderr, _ ("%s: option `%s' is ambiguous\n"),
    683                  argv[0], argv[optind]);
    684       nextchar += strlen (nextchar);
    685       optind++;
    686       optopt = 0;
    687       return '?';
    688     }
    689 
    690     if (pfound != NULL)
    691     {
    692       option_index = indfound;
    693       optind++;
    694       if (*nameend)
    695       {
    696         /* Don't test has_arg with >, because some C compilers don't
    697            allow it to be used on enums.  */
    698         if (pfound->has_arg)
    699           optarg = nameend + 1;
    700         else
    701         {
    702           if (opterr)
    703             if (argv[optind - 1][1] == '-')
    704               /* --option */
    705               fprintf (stderr,
    706                        _
    707                          ("%s: option `--%s' doesn't allow an argument\n"),
    708                        argv[0], pfound->name);
    709             else
    710               /* +option or -option */
    711               fprintf (stderr,
    712                        _
    713                          ("%s: option `%c%s' doesn't allow an argument\n"),
    714                        argv[0], argv[optind - 1][0], pfound->name);
    715 
    716           nextchar += strlen (nextchar);
    717 
    718           optopt = pfound->val;
    719           return '?';
    720         }
    721       }
    722       else if (pfound->has_arg == 1)
    723       {
    724         if (optind < argc)
    725           optarg = argv[optind++];
    726         else
    727         {
    728           if (opterr)
    729             fprintf (stderr,
    730                      _ ("%s: option `%s' requires an argument\n"),
    731                      argv[0], argv[optind - 1]);
    732           nextchar += strlen (nextchar);
    733           optopt = pfound->val;
    734           return optstring[0] == ':' ? ':' : '?';
    735         }
    736       }
    737       nextchar += strlen (nextchar);
    738       if (longind != NULL)
    739         *longind = option_index;
    740       if (pfound->flag)
    741       {
    742         *(pfound->flag) = pfound->val;
    743         return 0;
    744       }
    745       return pfound->val;
    746     }
    747 
    748     /* Can't find it as a long option.  If this is not getopt_long_only,
    749        or the option starts with '--' or is not a valid short
    750        option, then it's an error.
    751        Otherwise interpret it as a short option.  */
    752     if (! long_only || (argv[optind][1] == '-')
    753         || (my_index (optstring, *nextchar) == NULL) )
    754     {
    755       if (opterr)
    756       {
    757         if (argv[optind][1] == '-')
    758           /* --option */
    759           fprintf (stderr, _ ("%s: unrecognized option `--%s'\n"),
    760                    argv[0], nextchar);
    761         else
    762           /* +option or -option */
    763           fprintf (stderr, _ ("%s: unrecognized option `%c%s'\n"),
    764                    argv[0], argv[optind][0], nextchar);
    765       }
    766       nextchar = (char *) "";
    767       optind++;
    768       optopt = 0;
    769       return '?';
    770     }
    771   }
    772 
    773   /* Look at and handle the next short option-character.  */
    774 
    775   {
    776     char c = *nextchar++;
    777     char *temp = my_index (optstring, c);
    778 
    779     /* Increment `optind' when we start to process its last character.  */
    780     if (*nextchar == '\0')
    781       ++optind;
    782 
    783     if ((temp == NULL) || (c == ':'))
    784     {
    785       if (opterr)
    786       {
    787         if (posixly_correct)
    788           /* 1003.2 specifies the format of this message.  */
    789           fprintf (stderr, _ ("%s: illegal option -- %c\n"), argv[0], c);
    790         else
    791           fprintf (stderr, _ ("%s: invalid option -- %c\n"), argv[0], c);
    792       }
    793       optopt = c;
    794       return '?';
    795     }
    796     /* Convenience. Treat POSIX -W foo same as long option --foo */
    797     if ((temp[0] == 'W') && (temp[1] == ';'))
    798     {
    799       char *nameend;
    800       const struct option *p;
    801       const struct option *pfound = NULL;
    802       int exact = 0;
    803       int ambig = 0;
    804       int indfound = 0;
    805       int option_index;
    806 
    807       /* This is an option that requires an argument.  */
    808       if (*nextchar != '\0')
    809       {
    810         optarg = nextchar;
    811         /* If we end this ARGV-element by taking the rest as an arg,
    812            we must advance to the next element now.  */
    813         optind++;
    814       }
    815       else if (optind == argc)
    816       {
    817         if (opterr)
    818         {
    819           /* 1003.2 specifies the format of this message.  */
    820           fprintf (stderr, _ ("%s: option requires an argument -- %c\n"),
    821                    argv[0], c);
    822         }
    823         optopt = c;
    824         if (optstring[0] == ':')
    825           c = ':';
    826         else
    827           c = '?';
    828         return c;
    829       }
    830       else
    831         /* We already incremented `optind' once;
    832            increment it again when taking next ARGV-elt as argument.  */
    833         optarg = argv[optind++];
    834 
    835       /* optarg is now the argument, see if it's in the
    836          table of longopts.  */
    837 
    838       for (nextchar = nameend = optarg; *nameend && *nameend != '=';
    839            nameend++)
    840         /* Do nothing.  */;
    841 
    842       /* Test all long options for either exact match
    843          or abbreviated matches.  */
    844       for (p = longopts, option_index = 0; p->name; p++, option_index++)
    845         if (! strncmp (p->name, nextchar, nameend - nextchar))
    846         {
    847           if ((unsigned int) (nameend - nextchar) == strlen (p->name))
    848           {
    849             /* Exact match found.  */
    850             pfound = p;
    851             indfound = option_index;
    852             exact = 1;
    853             break;
    854           }
    855           else if (pfound == NULL)
    856           {
    857             /* First nonexact match found.  */
    858             pfound = p;
    859             indfound = option_index;
    860           }
    861           else
    862             /* Second or later nonexact match found.  */
    863             ambig = 1;
    864         }
    865       if (ambig && ! exact)
    866       {
    867         if (opterr)
    868           fprintf (stderr, _ ("%s: option `-W %s' is ambiguous\n"),
    869                    argv[0], argv[optind]);
    870         nextchar += strlen (nextchar);
    871         optind++;
    872         return '?';
    873       }
    874       if (pfound != NULL)
    875       {
    876         option_index = indfound;
    877         if (*nameend)
    878         {
    879           /* Don't test has_arg with >, because some C compilers don't
    880              allow it to be used on enums.  */
    881           if (pfound->has_arg)
    882             optarg = nameend + 1;
    883           else
    884           {
    885             if (opterr)
    886               fprintf (stderr, _ (
    887                          "\
    888 %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name);
    889 
    890             nextchar += strlen (nextchar);
    891             return '?';
    892           }
    893         }
    894         else if (pfound->has_arg == 1)
    895         {
    896           if (optind < argc)
    897             optarg = argv[optind++];
    898           else
    899           {
    900             if (opterr)
    901               fprintf (stderr,
    902                        _ ("%s: option `%s' requires an argument\n"),
    903                        argv[0], argv[optind - 1]);
    904             nextchar += strlen (nextchar);
    905             return optstring[0] == ':' ? ':' : '?';
    906           }
    907         }
    908         nextchar += strlen (nextchar);
    909         if (longind != NULL)
    910           *longind = option_index;
    911         if (pfound->flag)
    912         {
    913           *(pfound->flag) = pfound->val;
    914           return 0;
    915         }
    916         return pfound->val;
    917       }
    918       nextchar = NULL;
    919       return 'W'; /* Let the application handle it.   */
    920     }
    921     if (temp[1] == ':')
    922     {
    923       if (temp[2] == ':')
    924       {
    925         /* This is an option that accepts an argument optionally.  */
    926         if (*nextchar != '\0')
    927         {
    928           optarg = nextchar;
    929           optind++;
    930         }
    931         else
    932           optarg = NULL;
    933         nextchar = NULL;
    934       }
    935       else
    936       {
    937         /* This is an option that requires an argument.  */
    938         if (*nextchar != '\0')
    939         {
    940           optarg = nextchar;
    941           /* If we end this ARGV-element by taking the rest as an arg,
    942              we must advance to the next element now.  */
    943           optind++;
    944         }
    945         else if (optind == argc)
    946         {
    947           if (opterr)
    948           {
    949             /* 1003.2 specifies the format of this message.  */
    950             fprintf (stderr,
    951                      _ ("%s: option requires an argument -- %c\n"),
    952                      argv[0], c);
    953           }
    954           optopt = c;
    955           if (optstring[0] == ':')
    956             c = ':';
    957           else
    958             c = '?';
    959         }
    960         else
    961           /* We already incremented `optind' once;
    962              increment it again when taking next ARGV-elt as argument.  */
    963           optarg = argv[optind++];
    964         nextchar = NULL;
    965       }
    966     }
    967     return c;
    968   }
    969 }
    970 
    971 
    972 int
    973 getopt (int argc, char *const *argv, const char *optstring)
    974 {
    975   return _getopt_internal (argc, argv, optstring,
    976                            (const struct option *) 0, (int *) 0, 0);
    977 }
    978 
    979 
    980 #endif /* Not ELIDE_CODE.  */
    981 
    982 #ifdef TEST
    983 
    984 /* Compile with -DTEST to make an executable for use in testing
    985    the above definition of `getopt'.  */
    986 
    987 int
    988 main (int argc, char **argv)
    989 {
    990   int c;
    991   int digit_optind = 0;
    992 
    993   while (1)
    994   {
    995     int this_option_optind = optind ? optind : 1;
    996 
    997     c = getopt (argc, argv, "abc:d:0123456789");
    998     if (c == -1)
    999       break;
   1000 
   1001     switch (c)
   1002     {
   1003     case '0':
   1004     case '1':
   1005     case '2':
   1006     case '3':
   1007     case '4':
   1008     case '5':
   1009     case '6':
   1010     case '7':
   1011     case '8':
   1012     case '9':
   1013       if ((digit_optind != 0) && (digit_optind != this_option_optind) )
   1014         printf ("digits occur in two different argv-elements.\n");
   1015       digit_optind = this_option_optind;
   1016       printf ("option %c\n", c);
   1017       break;
   1018 
   1019     case 'a':
   1020       printf ("option a\n");
   1021       break;
   1022 
   1023     case 'b':
   1024       printf ("option b\n");
   1025       break;
   1026 
   1027     case 'c':
   1028       printf ("option c with value `%s'\n", optarg);
   1029       break;
   1030 
   1031     case '?':
   1032       break;
   1033 
   1034     default:
   1035       printf ("?? getopt returned character code 0%o ??\n", c);
   1036     }
   1037   }
   1038 
   1039   if (optind < argc)
   1040   {
   1041     printf ("non-option ARGV-elements: ");
   1042     while (optind < argc)
   1043       printf ("%s ", argv[optind++]);
   1044     printf ("\n");
   1045   }
   1046 
   1047   exit (0);
   1048 }
   1049 
   1050 
   1051 #endif /* TEST */