* Add this nice filesystem testing tool that I've recently
[dragonfly.git] / contrib / gperf / lib / getopt.c
1 /* Getopt for GNU.
2    NOTE: getopt is now part of the C library, so if you don't know what
3    "Keep this file name-space clean" means, talk to drepper@gnu.org
4    before changing it!
5
6    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98
7         Free Software Foundation, Inc.
8
9    The GNU C Library is free software; you can redistribute it and/or
10    modify it under the terms of the GNU Library General Public License as
11    published by the Free Software Foundation; either version 2 of the
12    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    Library General Public License for more details.
18
19    You should have received a copy of the GNU Library General Public
20    License along with the GNU C Library; see the file COPYING.LIB.  If not,
21    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22    Boston, MA 02111-1307, USA.  */
23 \f
24 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
25    Ditto for AIX 3.2 and <stdlib.h>.  */
26 #ifndef _NO_PROTO
27 #define _NO_PROTO
28 #endif
29
30 #ifdef HAVE_CONFIG_H
31 #include <config.h>
32 #endif
33
34 #if !defined __STDC__ || !__STDC__
35 /* This is a separate conditional since some stdc systems
36    reject `defined (const)'.  */
37 #ifndef const
38 #define const
39 #endif
40 #endif
41
42 #include <stdio.h>
43
44 /* Comment out all this code if we are using the GNU C Library, and are not
45    actually compiling the library itself.  This code is part of the GNU C
46    Library, but also included in many other GNU distributions.  Compiling
47    and linking in this code is a waste when using the GNU C library
48    (especially if it is a shared library).  Rather than having every GNU
49    program understand `configure --with-gnu-libc' and omit the object files,
50    it is simpler to just do this in the source for each such file.  */
51
52 #define GETOPT_INTERFACE_VERSION 2
53 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
54 #include <gnu-versions.h>
55 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
56 #define ELIDE_CODE
57 #endif
58 #endif
59
60 #ifndef ELIDE_CODE
61
62
63 /* This needs to come after some library #include
64    to get __GNU_LIBRARY__ defined.  */
65 #ifdef  __GNU_LIBRARY__
66 /* Don't include stdlib.h for non-GNU C libraries because some of them
67    contain conflicting prototypes for getopt.  */
68 #include <stdlib.h>
69 #include <unistd.h>
70 #endif  /* GNU C library.  */
71
72 #ifdef VMS
73 #include <unixlib.h>
74 #if HAVE_STRING_H - 0
75 #include <string.h>
76 #endif
77 #endif
78
79 #ifndef _
80 /* This is for other GNU distributions with internationalized messages.
81    When compiling libc, the _ macro is predefined.  */
82 #ifdef HAVE_LIBINTL_H
83 # include <libintl.h>
84 # define _(msgid)       gettext (msgid)
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 = NULL;
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 = 0;
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 \f
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 /* Avoid depending on library functions or files
202    whose names are inconsistent.  */
203
204 extern char *getenv ();
205 extern int strncmp ();
206
207 static char *
208 my_index (str, chr)
209      const char *str;
210      int chr;
211 {
212   while (*str)
213     {
214       if (*str == chr)
215         return (char *) str;
216       str++;
217     }
218   return 0;
219 }
220
221 /* If using GCC, we can safely declare strlen this way.
222    If not using GCC, it is ok not to declare it.  */
223 #ifdef __GNUC__
224 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
225    That was relevant to code that was here before.  */
226 #if !defined __STDC__ || !__STDC__
227 /* gcc with -traditional declares the built-in strlen to return int,
228    and has done so at least since version 2.4.5. -- rms.  */
229 extern int strlen (const char *);
230 #endif /* not __STDC__ */
231 #endif /* __GNUC__ */
232
233 #endif /* not __GNU_LIBRARY__ */
234 \f
235 /* Handle permutation of arguments.  */
236
237 /* Describe the part of ARGV that contains non-options that have
238    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
239    `last_nonopt' is the index after the last of them.  */
240
241 static int first_nonopt;
242 static int last_nonopt;
243
244 #ifdef _LIBC
245 /* Bash 2.0 gives us an environment variable containing flags
246    indicating ARGV elements that should not be considered arguments.  */
247
248 /* Defined in getopt_init.c  */
249 extern char *__getopt_nonoption_flags;
250
251 static int nonoption_flags_max_len;
252 static int nonoption_flags_len;
253
254 static int original_argc;
255 static char *const *original_argv;
256
257 /* Make sure the environment variable bash 2.0 puts in the environment
258    is valid for the getopt call we must make sure that the ARGV passed
259    to getopt is that one passed to the process.  */
260 static void
261 __attribute__ ((unused))
262 store_args_and_env (int argc, char *const *argv)
263 {
264   /* XXX This is no good solution.  We should rather copy the args so
265      that we can compare them later.  But we must not use malloc(3).  */
266   original_argc = argc;
267   original_argv = argv;
268 }
269 # ifdef text_set_element
270 text_set_element (__libc_subinit, store_args_and_env);
271 # endif /* text_set_element */
272
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   /* !_LIBC */
281 # define SWAP_FLAGS(ch1, ch2)
282 #endif  /* _LIBC */
283
284 /* Exchange two adjacent subsequences of ARGV.
285    One subsequence is elements [first_nonopt,last_nonopt)
286    which contains all the non-options that have been skipped so far.
287    The other is elements [last_nonopt,optind), which contains all
288    the options processed since those non-options were skipped.
289
290    `first_nonopt' and `last_nonopt' are relocated so that they describe
291    the new indices of the non-options in ARGV after they are moved.  */
292
293 #if defined __STDC__ && __STDC__
294 static void exchange (char **);
295 #endif
296
297 static void
298 exchange (argv)
299      char **argv;
300 {
301   int bottom = first_nonopt;
302   int middle = last_nonopt;
303   int top = optind;
304   char *tem;
305
306   /* Exchange the shorter segment with the far end of the longer segment.
307      That puts the shorter segment into the right place.
308      It leaves the longer segment in the right place overall,
309      but it consists of two parts that need to be swapped next.  */
310
311 #ifdef _LIBC
312   /* First make sure the handling of the `__getopt_nonoption_flags'
313      string can work normally.  Our top argument must be in the range
314      of the string.  */
315   if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
316     {
317       /* We must extend the array.  The user plays games with us and
318          presents new arguments.  */
319       char *new_str = malloc (top + 1);
320       if (new_str == NULL)
321         nonoption_flags_len = nonoption_flags_max_len = 0;
322       else
323         {
324           memset (__mempcpy (new_str, __getopt_nonoption_flags,
325                              nonoption_flags_max_len),
326                   '\0', top + 1 - nonoption_flags_max_len);
327           nonoption_flags_max_len = top + 1;
328           __getopt_nonoption_flags = new_str;
329         }
330     }
331 #endif
332
333   while (top > middle && middle > bottom)
334     {
335       if (top - middle > middle - bottom)
336         {
337           /* Bottom segment is the short one.  */
338           int len = middle - bottom;
339           register int i;
340
341           /* Swap it with the top part of the top segment.  */
342           for (i = 0; i < len; i++)
343             {
344               tem = argv[bottom + i];
345               argv[bottom + i] = argv[top - (middle - bottom) + i];
346               argv[top - (middle - bottom) + i] = tem;
347               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
348             }
349           /* Exclude the moved bottom segment from further swapping.  */
350           top -= len;
351         }
352       else
353         {
354           /* Top segment is the short one.  */
355           int len = top - middle;
356           register int i;
357
358           /* Swap it with the bottom part of the bottom segment.  */
359           for (i = 0; i < len; i++)
360             {
361               tem = argv[bottom + i];
362               argv[bottom + i] = argv[middle + i];
363               argv[middle + i] = tem;
364               SWAP_FLAGS (bottom + i, middle + i);
365             }
366           /* Exclude the moved top segment from further swapping.  */
367           bottom += len;
368         }
369     }
370
371   /* Update records for the slots the non-options now occupy.  */
372
373   first_nonopt += (optind - last_nonopt);
374   last_nonopt = optind;
375 }
376
377 /* Initialize the internal data when the first call is made.  */
378
379 #if defined __STDC__ && __STDC__
380 static const char *_getopt_initialize (int, char *const *, const char *);
381 #endif
382 static const char *
383 _getopt_initialize (argc, argv, optstring)
384      int argc;
385      char *const *argv;
386      const char *optstring;
387 {
388   /* Start processing options with ARGV-element 1 (since ARGV-element 0
389      is the program name); the sequence of previously skipped
390      non-option ARGV-elements is empty.  */
391
392   first_nonopt = last_nonopt = optind;
393
394   nextchar = NULL;
395
396   posixly_correct = getenv ("POSIXLY_CORRECT");
397
398   /* Determine how to handle the ordering of options and nonoptions.  */
399
400   if (optstring[0] == '-')
401     {
402       ordering = RETURN_IN_ORDER;
403       ++optstring;
404     }
405   else if (optstring[0] == '+')
406     {
407       ordering = REQUIRE_ORDER;
408       ++optstring;
409     }
410   else if (posixly_correct != NULL)
411     ordering = REQUIRE_ORDER;
412   else
413     ordering = PERMUTE;
414
415 #ifdef _LIBC
416   if (posixly_correct == NULL
417       && argc == original_argc && argv == original_argv)
418     {
419       if (nonoption_flags_max_len == 0)
420         {
421           if (__getopt_nonoption_flags == NULL
422               || __getopt_nonoption_flags[0] == '\0')
423             nonoption_flags_max_len = -1;
424           else
425             {
426               const char *orig_str = __getopt_nonoption_flags;
427               int len = nonoption_flags_max_len = strlen (orig_str);
428               if (nonoption_flags_max_len < argc)
429                 nonoption_flags_max_len = argc;
430               __getopt_nonoption_flags =
431                 (char *) malloc (nonoption_flags_max_len);
432               if (__getopt_nonoption_flags == NULL)
433                 nonoption_flags_max_len = -1;
434               else
435                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
436                         '\0', nonoption_flags_max_len - len);
437             }
438         }
439       nonoption_flags_len = nonoption_flags_max_len;
440     }
441   else
442     nonoption_flags_len = 0;
443 #endif
444
445   return optstring;
446 }
447 \f
448 /* Scan elements of ARGV (whose length is ARGC) for option characters
449    given in OPTSTRING.
450
451    If an element of ARGV starts with '-', and is not exactly "-" or "--",
452    then it is an option element.  The characters of this element
453    (aside from the initial '-') are option characters.  If `getopt'
454    is called repeatedly, it returns successively each of the option characters
455    from each of the option elements.
456
457    If `getopt' finds another option character, it returns that character,
458    updating `optind' and `nextchar' so that the next call to `getopt' can
459    resume the scan with the following option character or ARGV-element.
460
461    If there are no more option characters, `getopt' returns -1.
462    Then `optind' is the index in ARGV of the first ARGV-element
463    that is not an option.  (The ARGV-elements have been permuted
464    so that those that are not options now come last.)
465
466    OPTSTRING is a string containing the legitimate option characters.
467    If an option character is seen that is not listed in OPTSTRING,
468    return '?' after printing an error message.  If you set `opterr' to
469    zero, the error message is suppressed but we still return '?'.
470
471    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
472    so the following text in the same ARGV-element, or the text of the following
473    ARGV-element, is returned in `optarg'.  Two colons mean an option that
474    wants an optional arg; if there is text in the current ARGV-element,
475    it is returned in `optarg', otherwise `optarg' is set to zero.
476
477    If OPTSTRING starts with `-' or `+', it requests different methods of
478    handling the non-option ARGV-elements.
479    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
480
481    Long-named options begin with `--' instead of `-'.
482    Their names may be abbreviated as long as the abbreviation is unique
483    or is an exact match for some defined option.  If they have an
484    argument, it follows the option name in the same ARGV-element, separated
485    from the option name by a `=', or else the in next ARGV-element.
486    When `getopt' finds a long-named option, it returns 0 if that option's
487    `flag' field is nonzero, the value of the option's `val' field
488    if the `flag' field is zero.
489
490    The elements of ARGV aren't really const, because we permute them.
491    But we pretend they're const in the prototype to be compatible
492    with other systems.
493
494    LONGOPTS is a vector of `struct option' terminated by an
495    element containing a name which is zero.
496
497    LONGIND returns the index in LONGOPT of the long-named option found.
498    It is only valid when a long-named option has been found by the most
499    recent call.
500
501    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
502    long-named options.  */
503
504 int
505 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
506      int argc;
507      char *const *argv;
508      const char *optstring;
509      const struct option *longopts;
510      int *longind;
511      int long_only;
512 {
513   optarg = NULL;
514
515   if (optind == 0 || !__getopt_initialized)
516     {
517       if (optind == 0)
518         optind = 1;     /* Don't scan ARGV[0], the program name.  */
519       optstring = _getopt_initialize (argc, argv, optstring);
520       __getopt_initialized = 1;
521     }
522
523   /* Test whether ARGV[optind] points to a non-option argument.
524      Either it does not have option syntax, or there is an environment flag
525      from the shell indicating it is not an option.  The later information
526      is only used when the used in the GNU libc.  */
527 #ifdef _LIBC
528 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
529                      || (optind < nonoption_flags_len                         \
530                          && __getopt_nonoption_flags[optind] == '1'))
531 #else
532 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
533 #endif
534
535   if (nextchar == NULL || *nextchar == '\0')
536     {
537       /* Advance to the next ARGV-element.  */
538
539       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
540          moved back by the user (who may also have changed the arguments).  */
541       if (last_nonopt > optind)
542         last_nonopt = optind;
543       if (first_nonopt > optind)
544         first_nonopt = optind;
545
546       if (ordering == PERMUTE)
547         {
548           /* If we have just processed some options following some non-options,
549              exchange them so that the options come first.  */
550
551           if (first_nonopt != last_nonopt && last_nonopt != optind)
552             exchange ((char **) argv);
553           else if (last_nonopt != optind)
554             first_nonopt = optind;
555
556           /* Skip any additional non-options
557              and extend the range of non-options previously skipped.  */
558
559           while (optind < argc && NONOPTION_P)
560             optind++;
561           last_nonopt = optind;
562         }
563
564       /* The special ARGV-element `--' means premature end of options.
565          Skip it like a null option,
566          then exchange with previous non-options as if it were an option,
567          then skip everything else like a non-option.  */
568
569       if (optind != argc && !strcmp (argv[optind], "--"))
570         {
571           optind++;
572
573           if (first_nonopt != last_nonopt && last_nonopt != optind)
574             exchange ((char **) argv);
575           else if (first_nonopt == last_nonopt)
576             first_nonopt = optind;
577           last_nonopt = argc;
578
579           optind = argc;
580         }
581
582       /* If we have done all the ARGV-elements, stop the scan
583          and back over any non-options that we skipped and permuted.  */
584
585       if (optind == argc)
586         {
587           /* Set the next-arg-index to point at the non-options
588              that we previously skipped, so the caller will digest them.  */
589           if (first_nonopt != last_nonopt)
590             optind = first_nonopt;
591           return -1;
592         }
593
594       /* If we have come to a non-option and did not permute it,
595          either stop the scan or describe it to the caller and pass it by.  */
596
597       if (NONOPTION_P)
598         {
599           if (ordering == REQUIRE_ORDER)
600             return -1;
601           optarg = argv[optind++];
602           return 1;
603         }
604
605       /* We have found another option-ARGV-element.
606          Skip the initial punctuation.  */
607
608       nextchar = (argv[optind] + 1
609                   + (longopts != NULL && argv[optind][1] == '-'));
610     }
611
612   /* Decode the current option-ARGV-element.  */
613
614   /* Check whether the ARGV-element is a long option.
615
616      If long_only and the ARGV-element has the form "-f", where f is
617      a valid short option, don't consider it an abbreviated form of
618      a long option that starts with f.  Otherwise there would be no
619      way to give the -f short option.
620
621      On the other hand, if there's a long option "fubar" and
622      the ARGV-element is "-fu", do consider that an abbreviation of
623      the long option, just like "--fu", and not "-f" with arg "u".
624
625      This distinction seems to be the most useful approach.  */
626
627   if (longopts != NULL
628       && (argv[optind][1] == '-'
629           || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
630     {
631       char *nameend;
632       const struct option *p;
633       const struct option *pfound = NULL;
634       int exact = 0;
635       int ambig = 0;
636       int indfound = -1;
637       int option_index;
638
639       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
640         /* Do nothing.  */ ;
641
642       /* Test all long options for either exact match
643          or abbreviated matches.  */
644       for (p = longopts, option_index = 0; p->name; p++, option_index++)
645         if (!strncmp (p->name, nextchar, nameend - nextchar))
646           {
647             if ((unsigned int) (nameend - nextchar)
648                 == (unsigned int) strlen (p->name))
649               {
650                 /* Exact match found.  */
651                 pfound = p;
652                 indfound = option_index;
653                 exact = 1;
654                 break;
655               }
656             else if (pfound == NULL)
657               {
658                 /* First nonexact match found.  */
659                 pfound = p;
660                 indfound = option_index;
661               }
662             else
663               /* Second or later nonexact match found.  */
664               ambig = 1;
665           }
666
667       if (ambig && !exact)
668         {
669           if (opterr)
670             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
671                      argv[0], argv[optind]);
672           nextchar += strlen (nextchar);
673           optind++;
674           optopt = 0;
675           return '?';
676         }
677
678       if (pfound != NULL)
679         {
680           option_index = indfound;
681           optind++;
682           if (*nameend)
683             {
684               /* Don't test has_arg with >, because some C compilers don't
685                  allow it to be used on enums.  */
686               if (pfound->has_arg)
687                 optarg = nameend + 1;
688               else
689                 {
690                   if (opterr)
691                    if (argv[optind - 1][1] == '-')
692                     /* --option */
693                     fprintf (stderr,
694                      _("%s: option `--%s' doesn't allow an argument\n"),
695                      argv[0], pfound->name);
696                    else
697                     /* +option or -option */
698                     fprintf (stderr,
699                      _("%s: option `%c%s' doesn't allow an argument\n"),
700                      argv[0], argv[optind - 1][0], pfound->name);
701
702                   nextchar += strlen (nextchar);
703
704                   optopt = pfound->val;
705                   return '?';
706                 }
707             }
708           else if (pfound->has_arg == 1)
709             {
710               if (optind < argc)
711                 optarg = argv[optind++];
712               else
713                 {
714                   if (opterr)
715                     fprintf (stderr,
716                            _("%s: option `%s' requires an argument\n"),
717                            argv[0], argv[optind - 1]);
718                   nextchar += strlen (nextchar);
719                   optopt = pfound->val;
720                   return optstring[0] == ':' ? ':' : '?';
721                 }
722             }
723           nextchar += strlen (nextchar);
724           if (longind != NULL)
725             *longind = option_index;
726           if (pfound->flag)
727             {
728               *(pfound->flag) = pfound->val;
729               return 0;
730             }
731           return pfound->val;
732         }
733
734       /* Can't find it as a long option.  If this is not getopt_long_only,
735          or the option starts with '--' or is not a valid short
736          option, then it's an error.
737          Otherwise interpret it as a short option.  */
738       if (!long_only || argv[optind][1] == '-'
739           || my_index (optstring, *nextchar) == NULL)
740         {
741           if (opterr)
742             {
743               if (argv[optind][1] == '-')
744                 /* --option */
745                 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
746                          argv[0], nextchar);
747               else
748                 /* +option or -option */
749                 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
750                          argv[0], argv[optind][0], nextchar);
751             }
752           nextchar = (char *) "";
753           optind++;
754           optopt = 0;
755           return '?';
756         }
757     }
758
759   /* Look at and handle the next short option-character.  */
760
761   {
762     char c = *nextchar++;
763     char *temp = my_index (optstring, c);
764
765     /* Increment `optind' when we start to process its last character.  */
766     if (*nextchar == '\0')
767       ++optind;
768
769     if (temp == NULL || c == ':')
770       {
771         if (opterr)
772           {
773             if (posixly_correct)
774               /* 1003.2 specifies the format of this message.  */
775               fprintf (stderr, _("%s: illegal option -- %c\n"),
776                        argv[0], c);
777             else
778               fprintf (stderr, _("%s: invalid option -- %c\n"),
779                        argv[0], c);
780           }
781         optopt = c;
782         return '?';
783       }
784     /* Convenience. Treat POSIX -W foo same as long option --foo */
785     if (temp[0] == 'W' && temp[1] == ';')
786       {
787         char *nameend;
788         const struct option *p;
789         const struct option *pfound = NULL;
790         int exact = 0;
791         int ambig = 0;
792         int indfound = 0;
793         int option_index;
794
795         /* This is an option that requires an argument.  */
796         if (*nextchar != '\0')
797           {
798             optarg = nextchar;
799             /* If we end this ARGV-element by taking the rest as an arg,
800                we must advance to the next element now.  */
801             optind++;
802           }
803         else if (optind == argc)
804           {
805             if (opterr)
806               {
807                 /* 1003.2 specifies the format of this message.  */
808                 fprintf (stderr, _("%s: option requires an argument -- %c\n"),
809                          argv[0], c);
810               }
811             optopt = c;
812             if (optstring[0] == ':')
813               c = ':';
814             else
815               c = '?';
816             return c;
817           }
818         else
819           /* We already incremented `optind' once;
820              increment it again when taking next ARGV-elt as argument.  */
821           optarg = argv[optind++];
822
823         /* optarg is now the argument, see if it's in the
824            table of longopts.  */
825
826         for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
827           /* Do nothing.  */ ;
828
829         /* Test all long options for either exact match
830            or abbreviated matches.  */
831         for (p = longopts, option_index = 0; p->name; p++, option_index++)
832           if (!strncmp (p->name, nextchar, nameend - nextchar))
833             {
834               if ((unsigned int) (nameend - nextchar) == strlen (p->name))
835                 {
836                   /* Exact match found.  */
837                   pfound = p;
838                   indfound = option_index;
839                   exact = 1;
840                   break;
841                 }
842               else if (pfound == NULL)
843                 {
844                   /* First nonexact match found.  */
845                   pfound = p;
846                   indfound = option_index;
847                 }
848               else
849                 /* Second or later nonexact match found.  */
850                 ambig = 1;
851             }
852         if (ambig && !exact)
853           {
854             if (opterr)
855               fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
856                        argv[0], argv[optind]);
857             nextchar += strlen (nextchar);
858             optind++;
859             return '?';
860           }
861         if (pfound != NULL)
862           {
863             option_index = indfound;
864             if (*nameend)
865               {
866                 /* Don't test has_arg with >, because some C compilers don't
867                    allow it to be used on enums.  */
868                 if (pfound->has_arg)
869                   optarg = nameend + 1;
870                 else
871                   {
872                     if (opterr)
873                       fprintf (stderr, _("\
874 %s: option `-W %s' doesn't allow an argument\n"),
875                                argv[0], pfound->name);
876
877                     nextchar += strlen (nextchar);
878                     return '?';
879                   }
880               }
881             else if (pfound->has_arg == 1)
882               {
883                 if (optind < argc)
884                   optarg = argv[optind++];
885                 else
886                   {
887                     if (opterr)
888                       fprintf (stderr,
889                                _("%s: option `%s' requires an argument\n"),
890                                argv[0], argv[optind - 1]);
891                     nextchar += strlen (nextchar);
892                     return optstring[0] == ':' ? ':' : '?';
893                   }
894               }
895             nextchar += strlen (nextchar);
896             if (longind != NULL)
897               *longind = option_index;
898             if (pfound->flag)
899               {
900                 *(pfound->flag) = pfound->val;
901                 return 0;
902               }
903             return pfound->val;
904           }
905           nextchar = NULL;
906           return 'W';   /* Let the application handle it.   */
907       }
908     if (temp[1] == ':')
909       {
910         if (temp[2] == ':')
911           {
912             /* This is an option that accepts an argument optionally.  */
913             if (*nextchar != '\0')
914               {
915                 optarg = nextchar;
916                 optind++;
917               }
918             else
919               optarg = NULL;
920             nextchar = NULL;
921           }
922         else
923           {
924             /* This is an option that requires an argument.  */
925             if (*nextchar != '\0')
926               {
927                 optarg = nextchar;
928                 /* If we end this ARGV-element by taking the rest as an arg,
929                    we must advance to the next element now.  */
930                 optind++;
931               }
932             else if (optind == argc)
933               {
934                 if (opterr)
935                   {
936                     /* 1003.2 specifies the format of this message.  */
937                     fprintf (stderr,
938                            _("%s: option requires an argument -- %c\n"),
939                            argv[0], c);
940                   }
941                 optopt = c;
942                 if (optstring[0] == ':')
943                   c = ':';
944                 else
945                   c = '?';
946               }
947             else
948               /* We already incremented `optind' once;
949                  increment it again when taking next ARGV-elt as argument.  */
950               optarg = argv[optind++];
951             nextchar = NULL;
952           }
953       }
954     return c;
955   }
956 }
957
958 int
959 getopt (argc, argv, optstring)
960      int argc;
961      char *const *argv;
962      const char *optstring;
963 {
964   return _getopt_internal (argc, argv, optstring,
965                            (const struct option *) 0,
966                            (int *) 0,
967                            0);
968 }
969
970 #endif  /* Not ELIDE_CODE.  */
971 \f
972 #ifdef TEST
973
974 /* Compile with -DTEST to make an executable for use in testing
975    the above definition of `getopt'.  */
976
977 int
978 main (argc, argv)
979      int argc;
980      char **argv;
981 {
982   int c;
983   int digit_optind = 0;
984
985   while (1)
986     {
987       int this_option_optind = optind ? optind : 1;
988
989       c = getopt (argc, argv, "abc:d:0123456789");
990       if (c == -1)
991         break;
992
993       switch (c)
994         {
995         case '0':
996         case '1':
997         case '2':
998         case '3':
999         case '4':
1000         case '5':
1001         case '6':
1002         case '7':
1003         case '8':
1004         case '9':
1005           if (digit_optind != 0 && digit_optind != this_option_optind)
1006             printf ("digits occur in two different argv-elements.\n");
1007           digit_optind = this_option_optind;
1008           printf ("option %c\n", c);
1009           break;
1010
1011         case 'a':
1012           printf ("option a\n");
1013           break;
1014
1015         case 'b':
1016           printf ("option b\n");
1017           break;
1018
1019         case 'c':
1020           printf ("option c with value `%s'\n", optarg);
1021           break;
1022
1023         case '?':
1024           break;
1025
1026         default:
1027           printf ("?? getopt returned character code 0%o ??\n", c);
1028         }
1029     }
1030
1031   if (optind < argc)
1032     {
1033       printf ("non-option ARGV-elements: ");
1034       while (optind < argc)
1035         printf ("%s ", argv[optind++]);
1036       printf ("\n");
1037     }
1038
1039   exit (0);
1040 }
1041
1042 #endif /* TEST */