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