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