00001 /* Getopt for GNU.
00002    NOTE: getopt is now part of the C library, so if you don't know what
00003    "Keep this file name-space clean" means, talk to drepper@gnu.org
00004    before changing it!
00005 
00006    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
00007         Free Software Foundation, Inc.
00008 
00009    The GNU C Library is free software; you can redistribute it and/or
00010    modify it under the terms of the GNU Library General Public License as
00011    published by the Free Software Foundation; either version 2 of the
00012    License, or (at your option) any later version.
00013 
00014    The GNU C Library is distributed in the hope that it will be useful,
00015    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017    Library General Public License for more details.
00018 
00019    You should have received a copy of the GNU Library General Public
00020    License along with the GNU C Library; see the file COPYING.LIB.  If not,
00021    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00022    Boston, MA 02111-1307, USA.  */
00023 
00024 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
00025    Ditto for AIX 3.2 and <stdlib.h>.  */
00026 #ifndef _NO_PROTO
00027 # define _NO_PROTO
00028 #endif
00029 
00030 #ifdef HAVE_CONFIG_H
00031 # include <config.h>
00032 #endif
00033 
00034 #if !defined __STDC__ || !__STDC__
00035 /* This is a separate conditional since some stdc systems
00036    reject `defined (const)'.  */
00037 # ifndef const
00038 #  define const
00039 # endif
00040 #endif
00041 
00042 #include <stdio.h>
00043 
00044 /* Comment out all this code if we are using the GNU C Library, and are not
00045    actually compiling the library itself.  This code is part of the GNU C
00046    Library, but also included in many other GNU distributions.  Compiling
00047    and linking in this code is a waste when using the GNU C library
00048    (especially if it is a shared library).  Rather than having every GNU
00049    program understand `configure --with-gnu-libc' and omit the object files,
00050    it is simpler to just do this in the source for each such file.  */
00051 
00052 #define GETOPT_INTERFACE_VERSION 2
00053 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
00054 # include <gnu-versions.h>
00055 # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
00056 #  define ELIDE_CODE
00057 # endif
00058 #endif
00059 
00060 #ifndef ELIDE_CODE
00061 
00062 
00063 /* This needs to come after some library #include
00064    to get __GNU_LIBRARY__ defined.  */
00065 #ifdef  __GNU_LIBRARY__
00066 /* Don't include stdlib.h for non-GNU C libraries because some of them
00067    contain conflicting prototypes for getopt.  */
00068 # include <stdlib.h>
00069 # include <unistd.h>
00070 #endif  /* GNU C library.  */
00071 
00072 #ifdef VMS
00073 # include <unixlib.h>
00074 # if HAVE_STRING_H - 0
00075 #  include <string.h>
00076 # endif
00077 #endif
00078 
00079 #ifndef _
00080 /* This is for other GNU distributions with internationalized messages.
00081    When compiling libc, the _ macro is predefined.  */
00082 # ifdef HAVE_LIBINTL_H
00083 #  include <libintl.h>
00084 #  define _(msgid)      gettext (msgid)
00085 # else
00086 #  define _(msgid)      (msgid)
00087 # endif
00088 #endif
00089 
00090 /* This version of `getopt' appears to the caller like standard Unix `getopt'
00091    but it behaves differently for the user, since it allows the user
00092    to intersperse the options with the other arguments.
00093 
00094    As `getopt' works, it permutes the elements of ARGV so that,
00095    when it is done, all the options precede everything else.  Thus
00096    all application programs are extended to handle flexible argument order.
00097 
00098    Setting the environment variable POSIXLY_CORRECT disables permutation.
00099    Then the behavior is completely standard.
00100 
00101    GNU application programs can use a third alternative mode in which
00102    they can distinguish the relative order of options and other arguments.  */
00103 
00104 #include "getopt.h"
00105 
00106 /* For communication from `getopt' to the caller.
00107    When `getopt' finds an option that takes an argument,
00108    the argument value is returned here.
00109    Also, when `ordering' is RETURN_IN_ORDER,
00110    each non-option ARGV-element is returned here.  */
00111 
00112 char *optarg;
00113 
00114 /* Index in ARGV of the next element to be scanned.
00115    This is used for communication to and from the caller
00116    and for communication between successive calls to `getopt'.
00117 
00118    On entry to `getopt', zero means this is the first call; initialize.
00119 
00120    When `getopt' returns -1, this is the index of the first of the
00121    non-option elements that the caller should itself scan.
00122 
00123    Otherwise, `optind' communicates from one call to the next
00124    how much of ARGV has been scanned so far.  */
00125 
00126 /* 1003.2 says this must be 1 before any call.  */
00127 int optind = 1;
00128 
00129 /* Formerly, initialization of getopt depended on optind==0, which
00130    causes problems with re-calling getopt as programs generally don't
00131    know that. */
00132 
00133 int __getopt_initialized;
00134 
00135 /* The next char to be scanned in the option-element
00136    in which the last option character we returned was found.
00137    This allows us to pick up the scan where we left off.
00138 
00139    If this is zero, or a null string, it means resume the scan
00140    by advancing to the next ARGV-element.  */
00141 
00142 static char *nextchar;
00143 
00144 /* Callers store zero here to inhibit the error message
00145    for unrecognized options.  */
00146 
00147 int opterr = 1;
00148 
00149 /* Set to an option character which was unrecognized.
00150    This must be initialized on some systems to avoid linking in the
00151    system's own getopt implementation.  */
00152 
00153 int optopt = '?';
00154 
00155 /* Describe how to deal with options that follow non-option ARGV-elements.
00156 
00157    If the caller did not specify anything,
00158    the default is REQUIRE_ORDER if the environment variable
00159    POSIXLY_CORRECT is defined, PERMUTE otherwise.
00160 
00161    REQUIRE_ORDER means don't recognize them as options;
00162    stop option processing when the first non-option is seen.
00163    This is what Unix does.
00164    This mode of operation is selected by either setting the environment
00165    variable POSIXLY_CORRECT, or using `+' as the first character
00166    of the list of option characters.
00167 
00168    PERMUTE is the default.  We permute the contents of ARGV as we scan,
00169    so that eventually all the non-options are at the end.  This allows options
00170    to be given in any order, even with programs that were not written to
00171    expect this.
00172 
00173    RETURN_IN_ORDER is an option available to programs that were written
00174    to expect options and other ARGV-elements in any order and that care about
00175    the ordering of the two.  We describe each non-option ARGV-element
00176    as if it were the argument of an option with character code 1.
00177    Using `-' as the first character of the list of option characters
00178    selects this mode of operation.
00179 
00180    The special argument `--' forces an end of option-scanning regardless
00181    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
00182    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
00183 
00184 static enum
00185 {
00186   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
00187 } ordering;
00188 
00189 /* Value of POSIXLY_CORRECT environment variable.  */
00190 static char *posixly_correct;
00191 
00192 #ifdef  __GNU_LIBRARY__
00193 /* We want to avoid inclusion of string.h with non-GNU libraries
00194    because there are many ways it can cause trouble.
00195    On some systems, it contains special magic macros that don't work
00196    in GCC.  */
00197 # include <string.h>
00198 # define my_index       strchr
00199 #else
00200 
00201 # if HAVE_STRING_H
00202 #  include <string.h>
00203 # else
00204 #  include <strings.h>
00205 # endif
00206 
00207 /* Avoid depending on library functions or files
00208    whose names are inconsistent.  */
00209 
00210 #ifndef getenv
00211 extern char *getenv ();
00212 #endif
00213 
00214 static char *
00215 my_index (str, chr)
00216      const char *str;
00217      int chr;
00218 {
00219   while (*str)
00220     {
00221       if (*str == chr)
00222         return (char *) str;
00223       str++;
00224     }
00225   return 0;
00226 }
00227 
00228 /* If using GCC, we can safely declare strlen this way.
00229    If not using GCC, it is ok not to declare it.  */
00230 #ifdef __GNUC__
00231 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
00232    That was relevant to code that was here before.  */
00233 # if (!defined __STDC__ || !__STDC__) && !defined strlen
00234 /* gcc with -traditional declares the built-in strlen to return int,
00235    and has done so at least since version 2.4.5. -- rms.  */
00236 extern int strlen (const char *);
00237 # endif /* not __STDC__ */
00238 #endif /* __GNUC__ */
00239 
00240 #endif /* not __GNU_LIBRARY__ */
00241 
00242 /* Handle permutation of arguments.  */
00243 
00244 /* Describe the part of ARGV that contains non-options that have
00245    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
00246    `last_nonopt' is the index after the last of them.  */
00247 
00248 static int first_nonopt;
00249 static int last_nonopt;
00250 
00251 #ifdef _LIBC
00252 /* Bash 2.0 gives us an environment variable containing flags
00253    indicating ARGV elements that should not be considered arguments.  */
00254 
00255 /* Defined in getopt_init.c  */
00256 extern char *__getopt_nonoption_flags;
00257 
00258 static int nonoption_flags_max_len;
00259 static int nonoption_flags_len;
00260 
00261 static int original_argc;
00262 static char *const *original_argv;
00263 
00264 /* Make sure the environment variable bash 2.0 puts in the environment
00265    is valid for the getopt call we must make sure that the ARGV passed
00266    to getopt is that one passed to the process.  */
00267 static void
00268 __attribute__ ((unused))
00269 store_args_and_env (int argc, char *const *argv)
00270 {
00271   /* XXX This is no good solution.  We should rather copy the args so
00272      that we can compare them later.  But we must not use malloc(3).  */
00273   original_argc = argc;
00274   original_argv = argv;
00275 }
00276 # ifdef text_set_element
00277 text_set_element (__libc_subinit, store_args_and_env);
00278 # endif /* text_set_element */
00279 
00280 # define SWAP_FLAGS(ch1, ch2) \
00281   if (nonoption_flags_len > 0)                                                \
00282     {                                                                         \
00283       char __tmp = __getopt_nonoption_flags[ch1];                             \
00284       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
00285       __getopt_nonoption_flags[ch2] = __tmp;                                  \
00286     }
00287 #else   /* !_LIBC */
00288 # define SWAP_FLAGS(ch1, ch2)
00289 #endif  /* _LIBC */
00290 
00291 /* Exchange two adjacent subsequences of ARGV.
00292    One subsequence is elements [first_nonopt,last_nonopt)
00293    which contains all the non-options that have been skipped so far.
00294    The other is elements [last_nonopt,optind), which contains all
00295    the options processed since those non-options were skipped.
00296 
00297    `first_nonopt' and `last_nonopt' are relocated so that they describe
00298    the new indices of the non-options in ARGV after they are moved.  */
00299 
00300 #if defined __STDC__ && __STDC__
00301 static void exchange (char **);
00302 #endif
00303 
00304 static void
00305 exchange (argv)
00306      char **argv;
00307 {
00308   int bottom = first_nonopt;
00309   int middle = last_nonopt;
00310   int top = optind;
00311   char *tem;
00312 
00313   /* Exchange the shorter segment with the far end of the longer segment.
00314      That puts the shorter segment into the right place.
00315      It leaves the longer segment in the right place overall,
00316      but it consists of two parts that need to be swapped next.  */
00317 
00318 #ifdef _LIBC
00319   /* First make sure the handling of the `__getopt_nonoption_flags'
00320      string can work normally.  Our top argument must be in the range
00321      of the string.  */
00322   if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
00323     {
00324       /* We must extend the array.  The user plays games with us and
00325          presents new arguments.  */
00326       char *new_str = malloc (top + 1);
00327       if (new_str == NULL)
00328         nonoption_flags_len = nonoption_flags_max_len = 0;
00329       else
00330         {
00331           memset (__mempcpy (new_str, __getopt_nonoption_flags,
00332                              nonoption_flags_max_len),
00333                   '\0', top + 1 - nonoption_flags_max_len);
00334           nonoption_flags_max_len = top + 1;
00335           __getopt_nonoption_flags = new_str;
00336         }
00337     }
00338 #endif
00339 
00340   while (top > middle && middle > bottom)
00341     {
00342       if (top - middle > middle - bottom)
00343         {
00344           /* Bottom segment is the short one.  */
00345           int len = middle - bottom;
00346           register int i;
00347 
00348           /* Swap it with the top part of the top segment.  */
00349           for (i = 0; i < len; i++)
00350             {
00351               tem = argv[bottom + i];
00352               argv[bottom + i] = argv[top - (middle - bottom) + i];
00353               argv[top - (middle - bottom) + i] = tem;
00354               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
00355             }
00356           /* Exclude the moved bottom segment from further swapping.  */
00357           top -= len;
00358         }
00359       else
00360         {
00361           /* Top segment is the short one.  */
00362           int len = top - middle;
00363           register int i;
00364 
00365           /* Swap it with the bottom part of the bottom segment.  */
00366           for (i = 0; i < len; i++)
00367             {
00368               tem = argv[bottom + i];
00369               argv[bottom + i] = argv[middle + i];
00370               argv[middle + i] = tem;
00371               SWAP_FLAGS (bottom + i, middle + i);
00372             }
00373           /* Exclude the moved top segment from further swapping.  */
00374           bottom += len;
00375         }
00376     }
00377 
00378   /* Update records for the slots the non-options now occupy.  */
00379 
00380   first_nonopt += (optind - last_nonopt);
00381   last_nonopt = optind;
00382 }
00383 
00384 /* Initialize the internal data when the first call is made.  */
00385 
00386 #if defined __STDC__ && __STDC__
00387 static const char *_getopt_initialize (int, char *const *, const char *);
00388 #endif
00389 static const char *
00390 _getopt_initialize (argc, argv, optstring)
00391      int argc;
00392      char *const *argv;
00393      const char *optstring;
00394 {
00395   /* Start processing options with ARGV-element 1 (since ARGV-element 0
00396      is the program name); the sequence of previously skipped
00397      non-option ARGV-elements is empty.  */
00398 
00399   first_nonopt = last_nonopt = optind;
00400 
00401   nextchar = NULL;
00402 
00403   posixly_correct = getenv ("POSIXLY_CORRECT");
00404 
00405   /* Determine how to handle the ordering of options and nonoptions.  */
00406 
00407   if (optstring[0] == '-')
00408     {
00409       ordering = RETURN_IN_ORDER;
00410       ++optstring;
00411     }
00412   else if (optstring[0] == '+')
00413     {
00414       ordering = REQUIRE_ORDER;
00415       ++optstring;
00416     }
00417   else if (posixly_correct != NULL)
00418     ordering = REQUIRE_ORDER;
00419   else
00420     ordering = PERMUTE;
00421 
00422 #ifdef _LIBC
00423   if (posixly_correct == NULL
00424       && argc == original_argc && argv == original_argv)
00425     {
00426       if (nonoption_flags_max_len == 0)
00427         {
00428           if (__getopt_nonoption_flags == NULL
00429               || __getopt_nonoption_flags[0] == '\0')
00430             nonoption_flags_max_len = -1;
00431           else
00432             {
00433               const char *orig_str = __getopt_nonoption_flags;
00434               int len = nonoption_flags_max_len = strlen (orig_str);
00435               if (nonoption_flags_max_len < argc)
00436                 nonoption_flags_max_len = argc;
00437               __getopt_nonoption_flags =
00438                 (char *) malloc (nonoption_flags_max_len);
00439               if (__getopt_nonoption_flags == NULL)
00440                 nonoption_flags_max_len = -1;
00441               else
00442                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
00443                         '\0', nonoption_flags_max_len - len);
00444             }
00445         }
00446       nonoption_flags_len = nonoption_flags_max_len;
00447     }
00448   else
00449     nonoption_flags_len = 0;
00450 #endif
00451 
00452   return optstring;
00453 }
00454 
00455 /* Scan elements of ARGV (whose length is ARGC) for option characters
00456    given in OPTSTRING.
00457 
00458    If an element of ARGV starts with '-', and is not exactly "-" or "--",
00459    then it is an option element.  The characters of this element
00460    (aside from the initial '-') are option characters.  If `getopt'
00461    is called repeatedly, it returns successively each of the option characters
00462    from each of the option elements.
00463 
00464    If `getopt' finds another option character, it returns that character,
00465    updating `optind' and `nextchar' so that the next call to `getopt' can
00466    resume the scan with the following option character or ARGV-element.
00467 
00468    If there are no more option characters, `getopt' returns -1.
00469    Then `optind' is the index in ARGV of the first ARGV-element
00470    that is not an option.  (The ARGV-elements have been permuted
00471    so that those that are not options now come last.)
00472 
00473    OPTSTRING is a string containing the legitimate option characters.
00474    If an option character is seen that is not listed in OPTSTRING,
00475    return '?' after printing an error message.  If you set `opterr' to
00476    zero, the error message is suppressed but we still return '?'.
00477 
00478    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
00479    so the following text in the same ARGV-element, or the text of the following
00480    ARGV-element, is returned in `optarg'.  Two colons mean an option that
00481    wants an optional arg; if there is text in the current ARGV-element,
00482    it is returned in `optarg', otherwise `optarg' is set to zero.
00483 
00484    If OPTSTRING starts with `-' or `+', it requests different methods of
00485    handling the non-option ARGV-elements.
00486    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
00487 
00488    Long-named options begin with `--' instead of `-'.
00489    Their names may be abbreviated as long as the abbreviation is unique
00490    or is an exact match for some defined option.  If they have an
00491    argument, it follows the option name in the same ARGV-element, separated
00492    from the option name by a `=', or else the in next ARGV-element.
00493    When `getopt' finds a long-named option, it returns 0 if that option's
00494    `flag' field is nonzero, the value of the option's `val' field
00495    if the `flag' field is zero.
00496 
00497    The elements of ARGV aren't really const, because we permute them.
00498    But we pretend they're const in the prototype to be compatible
00499    with other systems.
00500 
00501    LONGOPTS is a vector of `struct option' terminated by an
00502    element containing a name which is zero.
00503 
00504    LONGIND returns the index in LONGOPT of the long-named option found.
00505    It is only valid when a long-named option has been found by the most
00506    recent call.
00507 
00508    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
00509    long-named options.  */
00510 
00511 int
00512 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
00513      int argc;
00514      char *const *argv;
00515      const char *optstring;
00516      const struct option *longopts;
00517      int *longind;
00518      int long_only;
00519 {
00520   int print_errors = opterr;
00521   if (optstring[0] == ':')
00522     print_errors = 0;
00523 
00524   optarg = NULL;
00525 
00526   if (optind == 0 || !__getopt_initialized)
00527     {
00528       if (optind == 0)
00529         optind = 1;     /* Don't scan ARGV[0], the program name.  */
00530       optstring = _getopt_initialize (argc, argv, optstring);
00531       __getopt_initialized = 1;
00532     }
00533 
00534   /* Test whether ARGV[optind] points to a non-option argument.
00535      Either it does not have option syntax, or there is an environment flag
00536      from the shell indicating it is not an option.  The later information
00537      is only used when the used in the GNU libc.  */
00538 #ifdef _LIBC
00539 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
00540                       || (optind < nonoption_flags_len                        \
00541                           && __getopt_nonoption_flags[optind] == '1'))
00542 #else
00543 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
00544 #endif
00545 
00546   if (nextchar == NULL || *nextchar == '\0')
00547     {
00548       /* Advance to the next ARGV-element.  */
00549 
00550       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
00551          moved back by the user (who may also have changed the arguments).  */
00552       if (last_nonopt > optind)
00553         last_nonopt = optind;
00554       if (first_nonopt > optind)
00555         first_nonopt = optind;
00556 
00557       if (ordering == PERMUTE)
00558         {
00559           /* If we have just processed some options following some non-options,
00560              exchange them so that the options come first.  */
00561 
00562           if (first_nonopt != last_nonopt && last_nonopt != optind)
00563             exchange ((char **) argv);
00564           else if (last_nonopt != optind)
00565             first_nonopt = optind;
00566 
00567           /* Skip any additional non-options
00568              and extend the range of non-options previously skipped.  */
00569 
00570           while (optind < argc && NONOPTION_P)
00571             optind++;
00572           last_nonopt = optind;
00573         }
00574 
00575       /* The special ARGV-element `--' means premature end of options.
00576          Skip it like a null option,
00577          then exchange with previous non-options as if it were an option,
00578          then skip everything else like a non-option.  */
00579 
00580       if (optind != argc && !strcmp (argv[optind], "--"))
00581         {
00582           optind++;
00583 
00584           if (first_nonopt != last_nonopt && last_nonopt != optind)
00585             exchange ((char **) argv);
00586           else if (first_nonopt == last_nonopt)
00587             first_nonopt = optind;
00588           last_nonopt = argc;
00589 
00590           optind = argc;
00591         }
00592 
00593       /* If we have done all the ARGV-elements, stop the scan
00594          and back over any non-options that we skipped and permuted.  */
00595 
00596       if (optind == argc)
00597         {
00598           /* Set the next-arg-index to point at the non-options
00599              that we previously skipped, so the caller will digest them.  */
00600           if (first_nonopt != last_nonopt)
00601             optind = first_nonopt;
00602           return -1;
00603         }
00604 
00605       /* If we have come to a non-option and did not permute it,
00606          either stop the scan or describe it to the caller and pass it by.  */
00607 
00608       if (NONOPTION_P)
00609         {
00610           if (ordering == REQUIRE_ORDER)
00611             return -1;
00612           optarg = argv[optind++];
00613           return 1;
00614         }
00615 
00616       /* We have found another option-ARGV-element.
00617          Skip the initial punctuation.  */
00618 
00619       nextchar = (argv[optind] + 1
00620                   + (longopts != NULL && argv[optind][1] == '-'));
00621     }
00622 
00623   /* Decode the current option-ARGV-element.  */
00624 
00625   /* Check whether the ARGV-element is a long option.
00626 
00627      If long_only and the ARGV-element has the form "-f", where f is
00628      a valid short option, don't consider it an abbreviated form of
00629      a long option that starts with f.  Otherwise there would be no
00630      way to give the -f short option.
00631 
00632      On the other hand, if there's a long option "fubar" and
00633      the ARGV-element is "-fu", do consider that an abbreviation of
00634      the long option, just like "--fu", and not "-f" with arg "u".
00635 
00636      This distinction seems to be the most useful approach.  */
00637 
00638   if (longopts != NULL
00639       && (argv[optind][1] == '-'
00640           || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
00641     {
00642       char *nameend;
00643       const struct option *p;
00644       const struct option *pfound = NULL;
00645       int exact = 0;
00646       int ambig = 0;
00647       int indfound = -1;
00648       int option_index;
00649 
00650       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
00651         /* Do nothing.  */ ;
00652 
00653       /* Test all long options for either exact match
00654          or abbreviated matches.  */
00655       for (p = longopts, option_index = 0; p->name; p++, option_index++)
00656         if (!strncmp (p->name, nextchar, nameend - nextchar))
00657           {
00658             if ((unsigned int) (nameend - nextchar)
00659                 == (unsigned int) strlen (p->name))
00660               {
00661                 /* Exact match found.  */
00662                 pfound = p;
00663                 indfound = option_index;
00664                 exact = 1;
00665                 break;
00666               }
00667             else if (pfound == NULL)
00668               {
00669                 /* First nonexact match found.  */
00670                 pfound = p;
00671                 indfound = option_index;
00672               }
00673             else
00674               /* Second or later nonexact match found.  */
00675               ambig = 1;
00676           }
00677 
00678       if (ambig && !exact)
00679         {
00680           if (print_errors)
00681             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
00682                      argv[0], argv[optind]);
00683           nextchar += strlen (nextchar);
00684           optind++;
00685           optopt = 0;
00686           return '?';
00687         }
00688 
00689       if (pfound != NULL)
00690         {
00691           option_index = indfound;
00692           optind++;
00693           if (*nameend)
00694             {
00695               /* Don't test has_arg with >, because some C compilers don't
00696                  allow it to be used on enums.  */
00697               if (pfound->has_arg)
00698                 optarg = nameend + 1;
00699               else
00700                 {
00701                   if (print_errors)
00702                     {
00703                       if (argv[optind - 1][1] == '-')
00704                         /* --option */
00705                         fprintf (stderr,
00706                                  _("%s: option `--%s' doesn't allow an argument\n"),
00707                                  argv[0], pfound->name);
00708                       else
00709                         /* +option or -option */
00710                         fprintf (stderr,
00711                                  _("%s: option `%c%s' doesn't allow an argument\n"),
00712                                  argv[0], argv[optind - 1][0], pfound->name);
00713                     }
00714 
00715                   nextchar += strlen (nextchar);
00716 
00717                   optopt = pfound->val;
00718                   return '?';
00719                 }
00720             }
00721           else if (pfound->has_arg == 1)
00722             {
00723               if (optind < argc)
00724                 optarg = argv[optind++];
00725               else
00726                 {
00727                   if (print_errors)
00728                     fprintf (stderr,
00729                            _("%s: option `%s' requires an argument\n"),
00730                            argv[0], argv[optind - 1]);
00731                   nextchar += strlen (nextchar);
00732                   optopt = pfound->val;
00733                   return optstring[0] == ':' ? ':' : '?';
00734                 }
00735             }
00736           nextchar += strlen (nextchar);
00737           if (longind != NULL)
00738             *longind = option_index;
00739           if (pfound->flag)
00740             {
00741               *(pfound->flag) = pfound->val;
00742               return 0;
00743             }
00744           return pfound->val;
00745         }
00746 
00747       /* Can't find it as a long option.  If this is not getopt_long_only,
00748          or the option starts with '--' or is not a valid short
00749          option, then it's an error.
00750          Otherwise interpret it as a short option.  */
00751       if (!long_only || argv[optind][1] == '-'
00752           || my_index (optstring, *nextchar) == NULL)
00753         {
00754           if (print_errors)
00755             {
00756               if (argv[optind][1] == '-')
00757                 /* --option */
00758                 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
00759                          argv[0], nextchar);
00760               else
00761                 /* +option or -option */
00762                 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
00763                          argv[0], argv[optind][0], nextchar);
00764             }
00765           nextchar = (char *) "";
00766           optind++;
00767           optopt = 0;
00768           return '?';
00769         }
00770     }
00771 
00772   /* Look at and handle the next short option-character.  */
00773 
00774   {
00775     char c = *nextchar++;
00776     char *temp = my_index (optstring, c);
00777 
00778     /* Increment `optind' when we start to process its last character.  */
00779     if (*nextchar == '\0')
00780       ++optind;
00781 
00782     if (temp == NULL || c == ':')
00783       {
00784         if (print_errors)
00785           {
00786             if (posixly_correct)
00787               /* 1003.2 specifies the format of this message.  */
00788               fprintf (stderr, _("%s: illegal option -- %c\n"),
00789                        argv[0], c);
00790             else
00791               fprintf (stderr, _("%s: invalid option -- %c\n"),
00792                        argv[0], c);
00793           }
00794         optopt = c;
00795         return '?';
00796       }
00797     /* Convenience. Treat POSIX -W foo same as long option --foo */
00798     if (temp[0] == 'W' && temp[1] == ';')
00799       {
00800         char *nameend;
00801         const struct option *p;
00802         const struct option *pfound = NULL;
00803         int exact = 0;
00804         int ambig = 0;
00805         int indfound = 0;
00806         int option_index;
00807 
00808         /* This is an option that requires an argument.  */
00809         if (*nextchar != '\0')
00810           {
00811             optarg = nextchar;
00812             /* If we end this ARGV-element by taking the rest as an arg,
00813                we must advance to the next element now.  */
00814             optind++;
00815           }
00816         else if (optind == argc)
00817           {
00818             if (print_errors)
00819               {
00820                 /* 1003.2 specifies the format of this message.  */
00821                 fprintf (stderr, _("%s: option requires an argument -- %c\n"),
00822                          argv[0], c);
00823               }
00824             optopt = c;
00825             if (optstring[0] == ':')
00826               c = ':';
00827             else
00828               c = '?';
00829             return c;
00830           }
00831         else
00832           /* We already incremented `optind' once;
00833              increment it again when taking next ARGV-elt as argument.  */
00834           optarg = argv[optind++];
00835 
00836         /* optarg is now the argument, see if it's in the
00837            table of longopts.  */
00838 
00839         for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
00840           /* Do nothing.  */ ;
00841 
00842         /* Test all long options for either exact match
00843            or abbreviated matches.  */
00844         for (p = longopts, option_index = 0; p->name; p++, option_index++)
00845           if (!strncmp (p->name, nextchar, nameend - nextchar))
00846             {
00847               if ((unsigned int) (nameend - nextchar) == strlen (p->name))
00848                 {
00849                   /* Exact match found.  */
00850                   pfound = p;
00851                   indfound = option_index;
00852                   exact = 1;
00853                   break;
00854                 }
00855               else if (pfound == NULL)
00856                 {
00857                   /* First nonexact match found.  */
00858                   pfound = p;
00859                   indfound = option_index;
00860                 }
00861               else
00862                 /* Second or later nonexact match found.  */
00863                 ambig = 1;
00864             }
00865         if (ambig && !exact)
00866           {
00867             if (print_errors)
00868               fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
00869                        argv[0], argv[optind]);
00870             nextchar += strlen (nextchar);
00871             optind++;
00872             return '?';
00873           }
00874         if (pfound != NULL)
00875           {
00876             option_index = indfound;
00877             if (*nameend)
00878               {
00879                 /* Don't test has_arg with >, because some C compilers don't
00880                    allow it to be used on enums.  */
00881                 if (pfound->has_arg)
00882                   optarg = nameend + 1;
00883                 else
00884                   {
00885                     if (print_errors)
00886                       fprintf (stderr, _("\
00887 %s: option `-W %s' doesn't allow an argument\n"),
00888                                argv[0], pfound->name);
00889 
00890                     nextchar += strlen (nextchar);
00891                     return '?';
00892                   }
00893               }
00894             else if (pfound->has_arg == 1)
00895               {
00896                 if (optind < argc)
00897                   optarg = argv[optind++];
00898                 else
00899                   {
00900                     if (print_errors)
00901                       fprintf (stderr,
00902                                _("%s: option `%s' requires an argument\n"),
00903                                argv[0], argv[optind - 1]);
00904                     nextchar += strlen (nextchar);
00905                     return optstring[0] == ':' ? ':' : '?';
00906                   }
00907               }
00908             nextchar += strlen (nextchar);
00909             if (longind != NULL)
00910               *longind = option_index;
00911             if (pfound->flag)
00912               {
00913                 *(pfound->flag) = pfound->val;
00914                 return 0;
00915               }
00916             return pfound->val;
00917           }
00918           nextchar = NULL;
00919           return 'W';   /* Let the application handle it.   */
00920       }
00921     if (temp[1] == ':')
00922       {
00923         if (temp[2] == ':')
00924           {
00925             /* This is an option that accepts an argument optionally.  */
00926             if (*nextchar != '\0')
00927               {
00928                 optarg = nextchar;
00929                 optind++;
00930               }
00931             else
00932               optarg = NULL;
00933             nextchar = NULL;
00934           }
00935         else
00936           {
00937             /* This is an option that requires an argument.  */
00938             if (*nextchar != '\0')
00939               {
00940                 optarg = nextchar;
00941                 /* If we end this ARGV-element by taking the rest as an arg,
00942                    we must advance to the next element now.  */
00943                 optind++;
00944               }
00945             else if (optind == argc)
00946               {
00947                 if (print_errors)
00948                   {
00949                     /* 1003.2 specifies the format of this message.  */
00950                     fprintf (stderr,
00951                              _("%s: option requires an argument -- %c\n"),
00952                              argv[0], c);
00953                   }
00954                 optopt = c;
00955                 if (optstring[0] == ':')
00956                   c = ':';
00957                 else
00958                   c = '?';
00959               }
00960             else
00961               /* We already incremented `optind' once;
00962                  increment it again when taking next ARGV-elt as argument.  */
00963               optarg = argv[optind++];
00964             nextchar = NULL;
00965           }
00966       }
00967     return c;
00968   }
00969 }
00970 
00971 int
00972 getopt (argc, argv, optstring)
00973      int argc;
00974      char *const *argv;
00975      const char *optstring;
00976 {
00977   return _getopt_internal (argc, argv, optstring,
00978                            (const struct option *) 0,
00979                            (int *) 0,
00980                            0);
00981 }
00982 
00983 #endif  /* Not ELIDE_CODE.  */
00984 
00985 #ifdef TEST
00986 
00987 /* Compile with -DTEST to make an executable for use in testing
00988    the above definition of `getopt'.  */
00989 
00990 int
00991 main (argc, argv)
00992      int argc;
00993      char **argv;
00994 {
00995   int c;
00996   int digit_optind = 0;
00997 
00998   while (1)
00999     {
01000       int this_option_optind = optind ? optind : 1;
01001 
01002       c = getopt (argc, argv, "abc:d:0123456789");
01003       if (c == -1)
01004         break;
01005 
01006       switch (c)
01007         {
01008         case '0':
01009         case '1':
01010         case '2':
01011         case '3':
01012         case '4':
01013         case '5':
01014         case '6':
01015         case '7':
01016         case '8':
01017         case '9':
01018           if (digit_optind != 0 && digit_optind != this_option_optind)
01019             printf ("digits occur in two different argv-elements.\n");
01020           digit_optind = this_option_optind;
01021           printf ("option %c\n", c);
01022           break;
01023 
01024         case 'a':
01025           printf ("option a\n");
01026           break;
01027 
01028         case 'b':
01029           printf ("option b\n");
01030           break;
01031 
01032         case 'c':
01033           printf ("option c with value `%s'\n", optarg);
01034           break;
01035 
01036         case '?':
01037           break;
01038 
01039         default:
01040           printf ("?? getopt returned character code 0%o ??\n", c);
01041         }
01042     }
01043 
01044   if (optind < argc)
01045     {
01046       printf ("non-option ARGV-elements: ");
01047       while (optind < argc)
01048         printf ("%s ", argv[optind++]);
01049       printf ("\n");
01050     }
01051 
01052   exit (0);
01053 }
01054 
01055 #endif /* TEST */