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