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