CanFestival: examples/TestMasterMicroMod/getopt.c Source File

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