"Fossies" - the Fresh Open Source Software Archive

Member "cpio-2.13/gnu/getopt.c" (2 Jan 2017, 41734 Bytes) of package /linux/misc/cpio-2.13.tar.bz2:


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.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 2.12_vs_2.13.

    1 /* Getopt for GNU.
    2    NOTE: getopt is part of the C library, so if you don't know what
    3    "Keep this file name-space clean" means, talk to drepper@gnu.org
    4    before changing it!
    5    Copyright (C) 1987-1996, 1998-2004, 2006, 2008-2017 Free Software
    6    Foundation, Inc.
    7    This file is part of the GNU C Library.
    8 
    9    This program is free software: you can redistribute it and/or modify
   10    it under the terms of the GNU General Public License as published by
   11    the Free Software Foundation; either version 3 of the License, or
   12    (at your option) any later version.
   13 
   14    This program is distributed in the hope that it will be useful,
   15    but WITHOUT ANY WARRANTY; without even the implied warranty of
   16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17    GNU General Public License for more details.
   18 
   19    You should have received a copy of the GNU General Public License
   20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   21 
   22 #ifndef _LIBC
   23 # include <config.h>
   24 #endif
   25 
   26 #include "getopt.h"
   27 
   28 #include <stdio.h>
   29 #include <stdlib.h>
   30 #include <string.h>
   31 #include <unistd.h>
   32 
   33 #ifdef _LIBC
   34 # include <libintl.h>
   35 #else
   36 # include "gettext.h"
   37 # define _(msgid) gettext (msgid)
   38 #endif
   39 
   40 #if defined _LIBC && defined USE_IN_LIBIO
   41 # include <wchar.h>
   42 #endif
   43 
   44 /* This version of 'getopt' appears to the caller like standard Unix 'getopt'
   45    but it behaves differently for the user, since it allows the user
   46    to intersperse the options with the other arguments.
   47 
   48    As 'getopt_long' works, it permutes the elements of ARGV so that,
   49    when it is done, all the options precede everything else.  Thus
   50    all application programs are extended to handle flexible argument order.
   51 
   52    Using 'getopt' or setting the environment variable POSIXLY_CORRECT
   53    disables permutation.
   54    Then the behavior is completely standard.
   55 
   56    GNU application programs can use a third alternative mode in which
   57    they can distinguish the relative order of options and other arguments.  */
   58 
   59 #include "getopt_int.h"
   60 
   61 /* For communication from 'getopt' to the caller.
   62    When 'getopt' finds an option that takes an argument,
   63    the argument value is returned here.
   64    Also, when 'ordering' is RETURN_IN_ORDER,
   65    each non-option ARGV-element is returned here.  */
   66 
   67 char *optarg;
   68 
   69 /* Index in ARGV of the next element to be scanned.
   70    This is used for communication to and from the caller
   71    and for communication between successive calls to 'getopt'.
   72 
   73    On entry to 'getopt', zero means this is the first call; initialize.
   74 
   75    When 'getopt' returns -1, this is the index of the first of the
   76    non-option elements that the caller should itself scan.
   77 
   78    Otherwise, 'optind' communicates from one call to the next
   79    how much of ARGV has been scanned so far.  */
   80 
   81 /* 1003.2 says this must be 1 before any call.  */
   82 int optind = 1;
   83 
   84 /* Callers store zero here to inhibit the error message
   85    for unrecognized options.  */
   86 
   87 int opterr = 1;
   88 
   89 /* Set to an option character which was unrecognized.
   90    This must be initialized on some systems to avoid linking in the
   91    system's own getopt implementation.  */
   92 
   93 int optopt = '?';
   94 
   95 /* Keep a global copy of all internal members of getopt_data.  */
   96 
   97 static struct _getopt_data getopt_data;
   98 
   99 
  100 #if defined HAVE_DECL_GETENV && !HAVE_DECL_GETENV
  101 extern char *getenv ();
  102 #endif
  103 
  104 #ifdef _LIBC
  105 /* Stored original parameters.
  106    XXX This is no good solution.  We should rather copy the args so
  107    that we can compare them later.  But we must not use malloc(3).  */
  108 extern int __libc_argc;
  109 extern char **__libc_argv;
  110 
  111 /* Bash 2.0 gives us an environment variable containing flags
  112    indicating ARGV elements that should not be considered arguments.  */
  113 
  114 # ifdef USE_NONOPTION_FLAGS
  115 /* Defined in getopt_init.c  */
  116 extern char *__getopt_nonoption_flags;
  117 # endif
  118 
  119 # ifdef USE_NONOPTION_FLAGS
  120 #  define SWAP_FLAGS(ch1, ch2) \
  121   if (d->__nonoption_flags_len > 0)                                           \
  122     {                                                                         \
  123       char __tmp = __getopt_nonoption_flags[ch1];                             \
  124       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
  125       __getopt_nonoption_flags[ch2] = __tmp;                                  \
  126     }
  127 # else
  128 #  define SWAP_FLAGS(ch1, ch2)
  129 # endif
  130 #else   /* !_LIBC */
  131 # define SWAP_FLAGS(ch1, ch2)
  132 #endif  /* _LIBC */
  133 
  134 /* Exchange two adjacent subsequences of ARGV.
  135    One subsequence is elements [first_nonopt,last_nonopt)
  136    which contains all the non-options that have been skipped so far.
  137    The other is elements [last_nonopt,optind), which contains all
  138    the options processed since those non-options were skipped.
  139 
  140    'first_nonopt' and 'last_nonopt' are relocated so that they describe
  141    the new indices of the non-options in ARGV after they are moved.  */
  142 
  143 static void
  144 exchange (char **argv, struct _getopt_data *d)
  145 {
  146   int bottom = d->__first_nonopt;
  147   int middle = d->__last_nonopt;
  148   int top = d->optind;
  149   char *tem;
  150 
  151   /* Exchange the shorter segment with the far end of the longer segment.
  152      That puts the shorter segment into the right place.
  153      It leaves the longer segment in the right place overall,
  154      but it consists of two parts that need to be swapped next.  */
  155 
  156 #if defined _LIBC && defined USE_NONOPTION_FLAGS
  157   /* First make sure the handling of the '__getopt_nonoption_flags'
  158      string can work normally.  Our top argument must be in the range
  159      of the string.  */
  160   if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
  161     {
  162       /* We must extend the array.  The user plays games with us and
  163          presents new arguments.  */
  164       char *new_str = malloc (top + 1);
  165       if (new_str == NULL)
  166         d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
  167       else
  168         {
  169           memset (__mempcpy (new_str, __getopt_nonoption_flags,
  170                              d->__nonoption_flags_max_len),
  171                   '\0', top + 1 - d->__nonoption_flags_max_len);
  172           d->__nonoption_flags_max_len = top + 1;
  173           __getopt_nonoption_flags = new_str;
  174         }
  175     }
  176 #endif
  177 
  178   while (top > middle && middle > bottom)
  179     {
  180       if (top - middle > middle - bottom)
  181         {
  182           /* Bottom segment is the short one.  */
  183           int len = middle - bottom;
  184           register int i;
  185 
  186           /* Swap it with the top part of the top segment.  */
  187           for (i = 0; i < len; i++)
  188             {
  189               tem = argv[bottom + i];
  190               argv[bottom + i] = argv[top - (middle - bottom) + i];
  191               argv[top - (middle - bottom) + i] = tem;
  192               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
  193             }
  194           /* Exclude the moved bottom segment from further swapping.  */
  195           top -= len;
  196         }
  197       else
  198         {
  199           /* Top segment is the short one.  */
  200           int len = top - middle;
  201           register int i;
  202 
  203           /* Swap it with the bottom part of the bottom segment.  */
  204           for (i = 0; i < len; i++)
  205             {
  206               tem = argv[bottom + i];
  207               argv[bottom + i] = argv[middle + i];
  208               argv[middle + i] = tem;
  209               SWAP_FLAGS (bottom + i, middle + i);
  210             }
  211           /* Exclude the moved top segment from further swapping.  */
  212           bottom += len;
  213         }
  214     }
  215 
  216   /* Update records for the slots the non-options now occupy.  */
  217 
  218   d->__first_nonopt += (d->optind - d->__last_nonopt);
  219   d->__last_nonopt = d->optind;
  220 }
  221 
  222 /* Initialize the internal data when the first call is made.  */
  223 
  224 static const char *
  225 _getopt_initialize (int argc _GL_UNUSED,
  226                     char **argv _GL_UNUSED, const char *optstring,
  227                     struct _getopt_data *d, int posixly_correct)
  228 {
  229   /* Start processing options with ARGV-element 1 (since ARGV-element 0
  230      is the program name); the sequence of previously skipped
  231      non-option ARGV-elements is empty.  */
  232 
  233   d->__first_nonopt = d->__last_nonopt = d->optind;
  234 
  235   d->__nextchar = NULL;
  236 
  237   d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
  238 
  239   /* Determine how to handle the ordering of options and nonoptions.  */
  240 
  241   if (optstring[0] == '-')
  242     {
  243       d->__ordering = RETURN_IN_ORDER;
  244       ++optstring;
  245     }
  246   else if (optstring[0] == '+')
  247     {
  248       d->__ordering = REQUIRE_ORDER;
  249       ++optstring;
  250     }
  251   else if (d->__posixly_correct)
  252     d->__ordering = REQUIRE_ORDER;
  253   else
  254     d->__ordering = PERMUTE;
  255 
  256 #if defined _LIBC && defined USE_NONOPTION_FLAGS
  257   if (!d->__posixly_correct
  258       && argc == __libc_argc && argv == __libc_argv)
  259     {
  260       if (d->__nonoption_flags_max_len == 0)
  261         {
  262           if (__getopt_nonoption_flags == NULL
  263               || __getopt_nonoption_flags[0] == '\0')
  264             d->__nonoption_flags_max_len = -1;
  265           else
  266             {
  267               const char *orig_str = __getopt_nonoption_flags;
  268               int len = d->__nonoption_flags_max_len = strlen (orig_str);
  269               if (d->__nonoption_flags_max_len < argc)
  270                 d->__nonoption_flags_max_len = argc;
  271               __getopt_nonoption_flags =
  272                 (char *) malloc (d->__nonoption_flags_max_len);
  273               if (__getopt_nonoption_flags == NULL)
  274                 d->__nonoption_flags_max_len = -1;
  275               else
  276                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
  277                         '\0', d->__nonoption_flags_max_len - len);
  278             }
  279         }
  280       d->__nonoption_flags_len = d->__nonoption_flags_max_len;
  281     }
  282   else
  283     d->__nonoption_flags_len = 0;
  284 #endif
  285 
  286   return optstring;
  287 }
  288 
  289 /* Scan elements of ARGV (whose length is ARGC) for option characters
  290    given in OPTSTRING.
  291 
  292    If an element of ARGV starts with '-', and is not exactly "-" or "--",
  293    then it is an option element.  The characters of this element
  294    (aside from the initial '-') are option characters.  If 'getopt'
  295    is called repeatedly, it returns successively each of the option characters
  296    from each of the option elements.
  297 
  298    If 'getopt' finds another option character, it returns that character,
  299    updating 'optind' and 'nextchar' so that the next call to 'getopt' can
  300    resume the scan with the following option character or ARGV-element.
  301 
  302    If there are no more option characters, 'getopt' returns -1.
  303    Then 'optind' is the index in ARGV of the first ARGV-element
  304    that is not an option.  (The ARGV-elements have been permuted
  305    so that those that are not options now come last.)
  306 
  307    OPTSTRING is a string containing the legitimate option characters.
  308    If an option character is seen that is not listed in OPTSTRING,
  309    return '?' after printing an error message.  If you set 'opterr' to
  310    zero, the error message is suppressed but we still return '?'.
  311 
  312    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
  313    so the following text in the same ARGV-element, or the text of the following
  314    ARGV-element, is returned in 'optarg'.  Two colons mean an option that
  315    wants an optional arg; if there is text in the current ARGV-element,
  316    it is returned in 'optarg', otherwise 'optarg' is set to zero.
  317 
  318    If OPTSTRING starts with '-' or '+', it requests different methods of
  319    handling the non-option ARGV-elements.
  320    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
  321 
  322    Long-named options begin with '--' instead of '-'.
  323    Their names may be abbreviated as long as the abbreviation is unique
  324    or is an exact match for some defined option.  If they have an
  325    argument, it follows the option name in the same ARGV-element, separated
  326    from the option name by a '=', or else the in next ARGV-element.
  327    When 'getopt' finds a long-named option, it returns 0 if that option's
  328    'flag' field is nonzero, the value of the option's 'val' field
  329    if the 'flag' field is zero.
  330 
  331    The elements of ARGV aren't really const, because we permute them.
  332    But we pretend they're const in the prototype to be compatible
  333    with other systems.
  334 
  335    LONGOPTS is a vector of 'struct option' terminated by an
  336    element containing a name which is zero.
  337 
  338    LONGIND returns the index in LONGOPT of the long-named option found.
  339    It is only valid when a long-named option has been found by the most
  340    recent call.
  341 
  342    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
  343    long-named options.  */
  344 
  345 int
  346 _getopt_internal_r (int argc, char **argv, const char *optstring,
  347                     const struct option *longopts, int *longind,
  348                     int long_only, struct _getopt_data *d, int posixly_correct)
  349 {
  350   int print_errors = d->opterr;
  351 
  352   if (argc < 1)
  353     return -1;
  354 
  355   d->optarg = NULL;
  356 
  357   if (d->optind == 0 || !d->__initialized)
  358     {
  359       if (d->optind == 0)
  360         d->optind = 1;  /* Don't scan ARGV[0], the program name.  */
  361       optstring = _getopt_initialize (argc, argv, optstring, d,
  362                                       posixly_correct);
  363       d->__initialized = 1;
  364     }
  365   else if (optstring[0] == '-' || optstring[0] == '+')
  366     optstring++;
  367   if (optstring[0] == ':')
  368     print_errors = 0;
  369 
  370   /* Test whether ARGV[optind] points to a non-option argument.
  371      Either it does not have option syntax, or there is an environment flag
  372      from the shell indicating it is not an option.  The later information
  373      is only used when the used in the GNU libc.  */
  374 #if defined _LIBC && defined USE_NONOPTION_FLAGS
  375 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
  376                       || (d->optind < d->__nonoption_flags_len                \
  377                           && __getopt_nonoption_flags[d->optind] == '1'))
  378 #else
  379 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
  380 #endif
  381 
  382   if (d->__nextchar == NULL || *d->__nextchar == '\0')
  383     {
  384       /* Advance to the next ARGV-element.  */
  385 
  386       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
  387          moved back by the user (who may also have changed the arguments).  */
  388       if (d->__last_nonopt > d->optind)
  389         d->__last_nonopt = d->optind;
  390       if (d->__first_nonopt > d->optind)
  391         d->__first_nonopt = d->optind;
  392 
  393       if (d->__ordering == PERMUTE)
  394         {
  395           /* If we have just processed some options following some non-options,
  396              exchange them so that the options come first.  */
  397 
  398           if (d->__first_nonopt != d->__last_nonopt
  399               && d->__last_nonopt != d->optind)
  400             exchange ((char **) argv, d);
  401           else if (d->__last_nonopt != d->optind)
  402             d->__first_nonopt = d->optind;
  403 
  404           /* Skip any additional non-options
  405              and extend the range of non-options previously skipped.  */
  406 
  407           while (d->optind < argc && NONOPTION_P)
  408             d->optind++;
  409           d->__last_nonopt = d->optind;
  410         }
  411 
  412       /* The special ARGV-element '--' means premature end of options.
  413          Skip it like a null option,
  414          then exchange with previous non-options as if it were an option,
  415          then skip everything else like a non-option.  */
  416 
  417       if (d->optind != argc && !strcmp (argv[d->optind], "--"))
  418         {
  419           d->optind++;
  420 
  421           if (d->__first_nonopt != d->__last_nonopt
  422               && d->__last_nonopt != d->optind)
  423             exchange ((char **) argv, d);
  424           else if (d->__first_nonopt == d->__last_nonopt)
  425             d->__first_nonopt = d->optind;
  426           d->__last_nonopt = argc;
  427 
  428           d->optind = argc;
  429         }
  430 
  431       /* If we have done all the ARGV-elements, stop the scan
  432          and back over any non-options that we skipped and permuted.  */
  433 
  434       if (d->optind == argc)
  435         {
  436           /* Set the next-arg-index to point at the non-options
  437              that we previously skipped, so the caller will digest them.  */
  438           if (d->__first_nonopt != d->__last_nonopt)
  439             d->optind = d->__first_nonopt;
  440           return -1;
  441         }
  442 
  443       /* If we have come to a non-option and did not permute it,
  444          either stop the scan or describe it to the caller and pass it by.  */
  445 
  446       if (NONOPTION_P)
  447         {
  448           if (d->__ordering == REQUIRE_ORDER)
  449             return -1;
  450           d->optarg = argv[d->optind++];
  451           return 1;
  452         }
  453 
  454       /* We have found another option-ARGV-element.
  455          Skip the initial punctuation.  */
  456 
  457       d->__nextchar = (argv[d->optind] + 1
  458                   + (longopts != NULL && argv[d->optind][1] == '-'));
  459     }
  460 
  461   /* Decode the current option-ARGV-element.  */
  462 
  463   /* Check whether the ARGV-element is a long option.
  464 
  465      If long_only and the ARGV-element has the form "-f", where f is
  466      a valid short option, don't consider it an abbreviated form of
  467      a long option that starts with f.  Otherwise there would be no
  468      way to give the -f short option.
  469 
  470      On the other hand, if there's a long option "fubar" and
  471      the ARGV-element is "-fu", do consider that an abbreviation of
  472      the long option, just like "--fu", and not "-f" with arg "u".
  473 
  474      This distinction seems to be the most useful approach.  */
  475 
  476   if (longopts != NULL
  477       && (argv[d->optind][1] == '-'
  478           || (long_only && (argv[d->optind][2]
  479                             || !strchr (optstring, argv[d->optind][1])))))
  480     {
  481       char *nameend;
  482       unsigned int namelen;
  483       const struct option *p;
  484       const struct option *pfound = NULL;
  485       struct option_list
  486       {
  487         const struct option *p;
  488         struct option_list *next;
  489       } *ambig_list = NULL;
  490 #ifdef _LIBC
  491 /* malloc() not used for _LIBC to simplify failure messages.  */
  492 # define free_option_list(l)
  493 #else
  494 # define free_option_list(l)            \
  495       while (l != NULL)             \
  496         {                   \
  497           struct option_list *pn = l->next; \
  498           free (l);             \
  499           l = pn;               \
  500         }
  501 #endif
  502       int exact = 0;
  503       int ambig = 0;
  504       int indfound = -1;
  505       int option_index;
  506 
  507       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
  508         /* Do nothing.  */ ;
  509       namelen = nameend - d->__nextchar;
  510 
  511       /* Test all long options for either exact match
  512          or abbreviated matches.  */
  513       for (p = longopts, option_index = 0; p->name; p++, option_index++)
  514         if (!strncmp (p->name, d->__nextchar, namelen))
  515           {
  516             if (namelen == (unsigned int) strlen (p->name))
  517               {
  518                 /* Exact match found.  */
  519                 pfound = p;
  520                 indfound = option_index;
  521                 exact = 1;
  522                 break;
  523               }
  524             else if (pfound == NULL)
  525               {
  526                 /* First nonexact match found.  */
  527                 pfound = p;
  528                 indfound = option_index;
  529               }
  530             else if (ambig)
  531               ; /* Taking simpler path to handling ambiguities.  */
  532             else if (long_only
  533                      || pfound->has_arg != p->has_arg
  534                      || pfound->flag != p->flag
  535                      || pfound->val != p->val)
  536               {
  537                 /* Second or later nonexact match found.  */
  538 #ifdef _LIBC
  539                 struct option_list *newp = alloca (sizeof (*newp));
  540 #else
  541                 struct option_list *newp = malloc (sizeof (*newp));
  542                 if (newp == NULL)
  543                   {
  544                     free_option_list (ambig_list);
  545                     ambig_list = NULL;
  546                     ambig = 1; /* Use simpler fallback message.  */
  547                   }
  548                 else
  549 #endif
  550                   {
  551                     newp->p = p;
  552                     newp->next = ambig_list;
  553                     ambig_list = newp;
  554                   }
  555               }
  556           }
  557 
  558       if ((ambig || ambig_list) && !exact)
  559         {
  560           if (print_errors && ambig_list)
  561             {
  562               struct option_list first;
  563               first.p = pfound;
  564               first.next = ambig_list;
  565               ambig_list = &first;
  566 
  567 #if defined _LIBC && defined USE_IN_LIBIO
  568               char *buf = NULL;
  569               size_t buflen = 0;
  570 
  571               FILE *fp = open_memstream (&buf, &buflen);
  572               if (fp != NULL)
  573                 {
  574                   fprintf (fp,
  575                            _("%s: option '%s' is ambiguous; possibilities:"),
  576                            argv[0], argv[d->optind]);
  577 
  578                   do
  579                     {
  580                       fprintf (fp, " '--%s'", ambig_list->p->name);
  581                       ambig_list = ambig_list->next;
  582                     }
  583                   while (ambig_list != NULL);
  584 
  585                   fputc_unlocked ('\n', fp);
  586 
  587                   if (__builtin_expect (fclose (fp) != EOF, 1))
  588                     {
  589                       _IO_flockfile (stderr);
  590 
  591                       int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  592                       ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  593 
  594                       __fxprintf (NULL, "%s", buf);
  595 
  596                       ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  597                       _IO_funlockfile (stderr);
  598 
  599                       free (buf);
  600                     }
  601                 }
  602 #else
  603               fprintf (stderr,
  604                        _("%s: option '%s' is ambiguous; possibilities:"),
  605                        argv[0], argv[d->optind]);
  606               do
  607                 {
  608                   fprintf (stderr, " '--%s'", ambig_list->p->name);
  609                   ambig_list = ambig_list->next;
  610                 }
  611               while (ambig_list != NULL);
  612 
  613               fputc ('\n', stderr);
  614 #endif
  615             }
  616           else if (print_errors && ambig)
  617             {
  618               fprintf (stderr,
  619                        _("%s: option '%s' is ambiguous\n"),
  620                        argv[0], argv[d->optind]);
  621             }
  622           d->__nextchar += strlen (d->__nextchar);
  623           d->optind++;
  624           d->optopt = 0;
  625           free_option_list (ambig_list);
  626           return '?';
  627         }
  628 
  629       free_option_list (ambig_list);
  630 
  631       if (pfound != NULL)
  632         {
  633           option_index = indfound;
  634           d->optind++;
  635           if (*nameend)
  636             {
  637               /* Don't test has_arg with >, because some C compilers don't
  638                  allow it to be used on enums.  */
  639               if (pfound->has_arg)
  640                 d->optarg = nameend + 1;
  641               else
  642                 {
  643                   if (print_errors)
  644                     {
  645 #if defined _LIBC && defined USE_IN_LIBIO
  646                       char *buf;
  647                       int n;
  648 #endif
  649 
  650                       if (argv[d->optind - 1][1] == '-')
  651                         {
  652                           /* --option */
  653 #if defined _LIBC && defined USE_IN_LIBIO
  654                           n = __asprintf (&buf, _("\
  655 %s: option '--%s' doesn't allow an argument\n"),
  656                                           argv[0], pfound->name);
  657 #else
  658                           fprintf (stderr, _("\
  659 %s: option '--%s' doesn't allow an argument\n"),
  660                                    argv[0], pfound->name);
  661 #endif
  662                         }
  663                       else
  664                         {
  665                           /* +option or -option */
  666 #if defined _LIBC && defined USE_IN_LIBIO
  667                           n = __asprintf (&buf, _("\
  668 %s: option '%c%s' doesn't allow an argument\n"),
  669                                           argv[0], argv[d->optind - 1][0],
  670                                           pfound->name);
  671 #else
  672                           fprintf (stderr, _("\
  673 %s: option '%c%s' doesn't allow an argument\n"),
  674                                    argv[0], argv[d->optind - 1][0],
  675                                    pfound->name);
  676 #endif
  677                         }
  678 
  679 #if defined _LIBC && defined USE_IN_LIBIO
  680                       if (n >= 0)
  681                         {
  682                           _IO_flockfile (stderr);
  683 
  684                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  685                           ((_IO_FILE *) stderr)->_flags2
  686                             |= _IO_FLAGS2_NOTCANCEL;
  687 
  688                           __fxprintf (NULL, "%s", buf);
  689 
  690                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  691                           _IO_funlockfile (stderr);
  692 
  693                           free (buf);
  694                         }
  695 #endif
  696                     }
  697 
  698                   d->__nextchar += strlen (d->__nextchar);
  699 
  700                   d->optopt = pfound->val;
  701                   return '?';
  702                 }
  703             }
  704           else if (pfound->has_arg == 1)
  705             {
  706               if (d->optind < argc)
  707                 d->optarg = argv[d->optind++];
  708               else
  709                 {
  710                   if (print_errors)
  711                     {
  712 #if defined _LIBC && defined USE_IN_LIBIO
  713                       char *buf;
  714 
  715                       if (__asprintf (&buf, _("\
  716 %s: option '--%s' requires an argument\n"),
  717                                       argv[0], pfound->name) >= 0)
  718                         {
  719                           _IO_flockfile (stderr);
  720 
  721                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  722                           ((_IO_FILE *) stderr)->_flags2
  723                             |= _IO_FLAGS2_NOTCANCEL;
  724 
  725                           __fxprintf (NULL, "%s", buf);
  726 
  727                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  728                           _IO_funlockfile (stderr);
  729 
  730                           free (buf);
  731                         }
  732 #else
  733                       fprintf (stderr,
  734                                _("%s: option '--%s' requires an argument\n"),
  735                                argv[0], pfound->name);
  736 #endif
  737                     }
  738                   d->__nextchar += strlen (d->__nextchar);
  739                   d->optopt = pfound->val;
  740                   return optstring[0] == ':' ? ':' : '?';
  741                 }
  742             }
  743           d->__nextchar += strlen (d->__nextchar);
  744           if (longind != NULL)
  745             *longind = option_index;
  746           if (pfound->flag)
  747             {
  748               *(pfound->flag) = pfound->val;
  749               return 0;
  750             }
  751           return pfound->val;
  752         }
  753 
  754       /* Can't find it as a long option.  If this is not getopt_long_only,
  755          or the option starts with '--' or is not a valid short
  756          option, then it's an error.
  757          Otherwise interpret it as a short option.  */
  758       if (!long_only || argv[d->optind][1] == '-'
  759           || strchr (optstring, *d->__nextchar) == NULL)
  760         {
  761           if (print_errors)
  762             {
  763 #if defined _LIBC && defined USE_IN_LIBIO
  764               char *buf;
  765               int n;
  766 #endif
  767 
  768               if (argv[d->optind][1] == '-')
  769                 {
  770                   /* --option */
  771 #if defined _LIBC && defined USE_IN_LIBIO
  772                   n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
  773                                   argv[0], d->__nextchar);
  774 #else
  775                   fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
  776                            argv[0], d->__nextchar);
  777 #endif
  778                 }
  779               else
  780                 {
  781                   /* +option or -option */
  782 #if defined _LIBC && defined USE_IN_LIBIO
  783                   n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
  784                                   argv[0], argv[d->optind][0], d->__nextchar);
  785 #else
  786                   fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
  787                            argv[0], argv[d->optind][0], d->__nextchar);
  788 #endif
  789                 }
  790 
  791 #if defined _LIBC && defined USE_IN_LIBIO
  792               if (n >= 0)
  793                 {
  794                   _IO_flockfile (stderr);
  795 
  796                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  797                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  798 
  799                   __fxprintf (NULL, "%s", buf);
  800 
  801                   ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  802                   _IO_funlockfile (stderr);
  803 
  804                   free (buf);
  805                 }
  806 #endif
  807             }
  808           d->__nextchar = (char *) "";
  809           d->optind++;
  810           d->optopt = 0;
  811           return '?';
  812         }
  813     }
  814 
  815   /* Look at and handle the next short option-character.  */
  816 
  817   {
  818     char c = *d->__nextchar++;
  819     const char *temp = strchr (optstring, c);
  820 
  821     /* Increment 'optind' when we start to process its last character.  */
  822     if (*d->__nextchar == '\0')
  823       ++d->optind;
  824 
  825     if (temp == NULL || c == ':' || c == ';')
  826       {
  827         if (print_errors)
  828           {
  829 #if defined _LIBC && defined USE_IN_LIBIO
  830               char *buf;
  831               int n;
  832 #endif
  833 
  834 #if defined _LIBC && defined USE_IN_LIBIO
  835               n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
  836                               argv[0], c);
  837 #else
  838               fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
  839 #endif
  840 
  841 #if defined _LIBC && defined USE_IN_LIBIO
  842             if (n >= 0)
  843               {
  844                 _IO_flockfile (stderr);
  845 
  846                 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  847                 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  848 
  849                 __fxprintf (NULL, "%s", buf);
  850 
  851                 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  852                 _IO_funlockfile (stderr);
  853 
  854                 free (buf);
  855               }
  856 #endif
  857           }
  858         d->optopt = c;
  859         return '?';
  860       }
  861     /* Convenience. Treat POSIX -W foo same as long option --foo */
  862     if (temp[0] == 'W' && temp[1] == ';')
  863       {
  864         char *nameend;
  865         const struct option *p;
  866         const struct option *pfound = NULL;
  867         int exact = 0;
  868         int ambig = 0;
  869         int indfound = 0;
  870         int option_index;
  871 
  872         if (longopts == NULL)
  873           goto no_longs;
  874 
  875         /* This is an option that requires an argument.  */
  876         if (*d->__nextchar != '\0')
  877           {
  878             d->optarg = d->__nextchar;
  879             /* If we end this ARGV-element by taking the rest as an arg,
  880                we must advance to the next element now.  */
  881             d->optind++;
  882           }
  883         else if (d->optind == argc)
  884           {
  885             if (print_errors)
  886               {
  887 #if defined _LIBC && defined USE_IN_LIBIO
  888                 char *buf;
  889 
  890                 if (__asprintf (&buf,
  891                                 _("%s: option requires an argument -- '%c'\n"),
  892                                 argv[0], c) >= 0)
  893                   {
  894                     _IO_flockfile (stderr);
  895 
  896                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  897                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  898 
  899                     __fxprintf (NULL, "%s", buf);
  900 
  901                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  902                     _IO_funlockfile (stderr);
  903 
  904                     free (buf);
  905                   }
  906 #else
  907                 fprintf (stderr,
  908                          _("%s: option requires an argument -- '%c'\n"),
  909                          argv[0], c);
  910 #endif
  911               }
  912             d->optopt = c;
  913             if (optstring[0] == ':')
  914               c = ':';
  915             else
  916               c = '?';
  917             return c;
  918           }
  919         else
  920           /* We already incremented 'd->optind' once;
  921              increment it again when taking next ARGV-elt as argument.  */
  922           d->optarg = argv[d->optind++];
  923 
  924         /* optarg is now the argument, see if it's in the
  925            table of longopts.  */
  926 
  927         for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
  928              nameend++)
  929           /* Do nothing.  */ ;
  930 
  931         /* Test all long options for either exact match
  932            or abbreviated matches.  */
  933         for (p = longopts, option_index = 0; p->name; p++, option_index++)
  934           if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
  935             {
  936               if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
  937                 {
  938                   /* Exact match found.  */
  939                   pfound = p;
  940                   indfound = option_index;
  941                   exact = 1;
  942                   break;
  943                 }
  944               else if (pfound == NULL)
  945                 {
  946                   /* First nonexact match found.  */
  947                   pfound = p;
  948                   indfound = option_index;
  949                 }
  950               else if (long_only
  951                        || pfound->has_arg != p->has_arg
  952                        || pfound->flag != p->flag
  953                        || pfound->val != p->val)
  954                 /* Second or later nonexact match found.  */
  955                 ambig = 1;
  956             }
  957         if (ambig && !exact)
  958           {
  959             if (print_errors)
  960               {
  961 #if defined _LIBC && defined USE_IN_LIBIO
  962                 char *buf;
  963 
  964                 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
  965                                 argv[0], d->optarg) >= 0)
  966                   {
  967                     _IO_flockfile (stderr);
  968 
  969                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
  970                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
  971 
  972                     __fxprintf (NULL, "%s", buf);
  973 
  974                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
  975                     _IO_funlockfile (stderr);
  976 
  977                     free (buf);
  978                   }
  979 #else
  980                 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
  981                          argv[0], d->optarg);
  982 #endif
  983               }
  984             d->__nextchar += strlen (d->__nextchar);
  985             d->optind++;
  986             return '?';
  987           }
  988         if (pfound != NULL)
  989           {
  990             option_index = indfound;
  991             if (*nameend)
  992               {
  993                 /* Don't test has_arg with >, because some C compilers don't
  994                    allow it to be used on enums.  */
  995                 if (pfound->has_arg)
  996                   d->optarg = nameend + 1;
  997                 else
  998                   {
  999                     if (print_errors)
 1000                       {
 1001 #if defined _LIBC && defined USE_IN_LIBIO
 1002                         char *buf;
 1003 
 1004                         if (__asprintf (&buf, _("\
 1005 %s: option '-W %s' doesn't allow an argument\n"),
 1006                                         argv[0], pfound->name) >= 0)
 1007                           {
 1008                             _IO_flockfile (stderr);
 1009 
 1010                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 1011                             ((_IO_FILE *) stderr)->_flags2
 1012                               |= _IO_FLAGS2_NOTCANCEL;
 1013 
 1014                             __fxprintf (NULL, "%s", buf);
 1015 
 1016                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 1017                             _IO_funlockfile (stderr);
 1018 
 1019                             free (buf);
 1020                           }
 1021 #else
 1022                         fprintf (stderr, _("\
 1023 %s: option '-W %s' doesn't allow an argument\n"),
 1024                                  argv[0], pfound->name);
 1025 #endif
 1026                       }
 1027 
 1028                     d->__nextchar += strlen (d->__nextchar);
 1029                     return '?';
 1030                   }
 1031               }
 1032             else if (pfound->has_arg == 1)
 1033               {
 1034                 if (d->optind < argc)
 1035                   d->optarg = argv[d->optind++];
 1036                 else
 1037                   {
 1038                     if (print_errors)
 1039                       {
 1040 #if defined _LIBC && defined USE_IN_LIBIO
 1041                         char *buf;
 1042 
 1043                         if (__asprintf (&buf, _("\
 1044 %s: option '-W %s' requires an argument\n"),
 1045                                         argv[0], pfound->name) >= 0)
 1046                           {
 1047                             _IO_flockfile (stderr);
 1048 
 1049                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 1050                             ((_IO_FILE *) stderr)->_flags2
 1051                               |= _IO_FLAGS2_NOTCANCEL;
 1052 
 1053                             __fxprintf (NULL, "%s", buf);
 1054 
 1055                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 1056                             _IO_funlockfile (stderr);
 1057 
 1058                             free (buf);
 1059                           }
 1060 #else
 1061                         fprintf (stderr, _("\
 1062 %s: option '-W %s' requires an argument\n"),
 1063                                  argv[0], pfound->name);
 1064 #endif
 1065                       }
 1066                     d->__nextchar += strlen (d->__nextchar);
 1067                     return optstring[0] == ':' ? ':' : '?';
 1068                   }
 1069               }
 1070             else
 1071               d->optarg = NULL;
 1072             d->__nextchar += strlen (d->__nextchar);
 1073             if (longind != NULL)
 1074               *longind = option_index;
 1075             if (pfound->flag)
 1076               {
 1077                 *(pfound->flag) = pfound->val;
 1078                 return 0;
 1079               }
 1080             return pfound->val;
 1081           }
 1082 
 1083       no_longs:
 1084         d->__nextchar = NULL;
 1085         return 'W';   /* Let the application handle it.   */
 1086       }
 1087     if (temp[1] == ':')
 1088       {
 1089         if (temp[2] == ':')
 1090           {
 1091             /* This is an option that accepts an argument optionally.  */
 1092             if (*d->__nextchar != '\0')
 1093               {
 1094                 d->optarg = d->__nextchar;
 1095                 d->optind++;
 1096               }
 1097             else
 1098               d->optarg = NULL;
 1099             d->__nextchar = NULL;
 1100           }
 1101         else
 1102           {
 1103             /* This is an option that requires an argument.  */
 1104             if (*d->__nextchar != '\0')
 1105               {
 1106                 d->optarg = d->__nextchar;
 1107                 /* If we end this ARGV-element by taking the rest as an arg,
 1108                    we must advance to the next element now.  */
 1109                 d->optind++;
 1110               }
 1111             else if (d->optind == argc)
 1112               {
 1113                 if (print_errors)
 1114                   {
 1115 #if defined _LIBC && defined USE_IN_LIBIO
 1116                     char *buf;
 1117 
 1118                     if (__asprintf (&buf, _("\
 1119 %s: option requires an argument -- '%c'\n"),
 1120                                     argv[0], c) >= 0)
 1121                       {
 1122                         _IO_flockfile (stderr);
 1123 
 1124                         int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 1125                         ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 1126 
 1127                         __fxprintf (NULL, "%s", buf);
 1128 
 1129                         ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 1130                         _IO_funlockfile (stderr);
 1131 
 1132                         free (buf);
 1133                       }
 1134 #else
 1135                     fprintf (stderr,
 1136                              _("%s: option requires an argument -- '%c'\n"),
 1137                              argv[0], c);
 1138 #endif
 1139                   }
 1140                 d->optopt = c;
 1141                 if (optstring[0] == ':')
 1142                   c = ':';
 1143                 else
 1144                   c = '?';
 1145               }
 1146             else
 1147               /* We already incremented 'optind' once;
 1148                  increment it again when taking next ARGV-elt as argument.  */
 1149               d->optarg = argv[d->optind++];
 1150             d->__nextchar = NULL;
 1151           }
 1152       }
 1153     return c;
 1154   }
 1155 }
 1156 
 1157 int
 1158 _getopt_internal (int argc, char **argv, const char *optstring,
 1159                   const struct option *longopts, int *longind, int long_only,
 1160                   int posixly_correct)
 1161 {
 1162   int result;
 1163 
 1164   getopt_data.optind = optind;
 1165   getopt_data.opterr = opterr;
 1166 
 1167   result = _getopt_internal_r (argc, argv, optstring, longopts,
 1168                                longind, long_only, &getopt_data,
 1169                                posixly_correct);
 1170 
 1171   optind = getopt_data.optind;
 1172   optarg = getopt_data.optarg;
 1173   optopt = getopt_data.optopt;
 1174 
 1175   return result;
 1176 }
 1177 
 1178 /* glibc gets a LSB-compliant getopt.
 1179    Standalone applications get a POSIX-compliant getopt.  */
 1180 #if _LIBC
 1181 enum { POSIXLY_CORRECT = 0 };
 1182 #else
 1183 enum { POSIXLY_CORRECT = 1 };
 1184 #endif
 1185 
 1186 int
 1187 getopt (int argc, char *const *argv, const char *optstring)
 1188 {
 1189   return _getopt_internal (argc, (char **) argv, optstring,
 1190                            (const struct option *) 0,
 1191                            (int *) 0,
 1192                            0, POSIXLY_CORRECT);
 1193 }
 1194 
 1195 #ifdef _LIBC
 1196 int
 1197 __posix_getopt (int argc, char *const *argv, const char *optstring)
 1198 {
 1199   return _getopt_internal (argc, argv, optstring,
 1200                            (const struct option *) 0,
 1201                            (int *) 0,
 1202                            0, 1);
 1203 }
 1204 #endif
 1205 
 1206 
 1207 #ifdef TEST
 1208 
 1209 /* Compile with -DTEST to make an executable for use in testing
 1210    the above definition of 'getopt'.  */
 1211 
 1212 int
 1213 main (int argc, char **argv)
 1214 {
 1215   int c;
 1216   int digit_optind = 0;
 1217 
 1218   while (1)
 1219     {
 1220       int this_option_optind = optind ? optind : 1;
 1221 
 1222       c = getopt (argc, argv, "abc:d:0123456789");
 1223       if (c == -1)
 1224         break;
 1225 
 1226       switch (c)
 1227         {
 1228         case '0':
 1229         case '1':
 1230         case '2':
 1231         case '3':
 1232         case '4':
 1233         case '5':
 1234         case '6':
 1235         case '7':
 1236         case '8':
 1237         case '9':
 1238           if (digit_optind != 0 && digit_optind != this_option_optind)
 1239             printf ("digits occur in two different argv-elements.\n");
 1240           digit_optind = this_option_optind;
 1241           printf ("option %c\n", c);
 1242           break;
 1243 
 1244         case 'a':
 1245           printf ("option a\n");
 1246           break;
 1247 
 1248         case 'b':
 1249           printf ("option b\n");
 1250           break;
 1251 
 1252         case 'c':
 1253           printf ("option c with value '%s'\n", optarg);
 1254           break;
 1255 
 1256         case '?':
 1257           break;
 1258 
 1259         default:
 1260           printf ("?? getopt returned character code 0%o ??\n", c);
 1261         }
 1262     }
 1263 
 1264   if (optind < argc)
 1265     {
 1266       printf ("non-option ARGV-elements: ");
 1267       while (optind < argc)
 1268         printf ("%s ", argv[optind++]);
 1269       printf ("\n");
 1270     }
 1271 
 1272   exit (0);
 1273 }
 1274 
 1275 #endif /* TEST */