"Fossies" - the Fresh Open Source Software Archive

Member "libspf2-1.2.10/src/libreplace/getopt_long_only.c" (28 Jan 2012, 30673 Bytes) of package /linux/privat/libspf2-1.2.10.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "getopt_long_only.c" see the Fossies "Dox" file reference documentation.

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