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