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