Add per-device polling support.
[dragonfly.git] / contrib / texinfo / lib / getopt.c
1 /* Getopt for GNU.
2    NOTE: The canonical source of this file is maintained with the GNU
3    C Library.  Bugs can be reported to bug-glibc@gnu.org.
4
5    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
6         Free Software Foundation, Inc.
7
8    This program is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published by the
10    Free Software Foundation; either version 2, or (at your option) any
11    later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software Foundation,
20    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
21 \f
22 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
23    Ditto for AIX 3.2 and <stdlib.h>.  */
24 #ifndef _NO_PROTO
25 # define _NO_PROTO
26 #endif
27
28 #ifdef HAVE_CONFIG_H
29 # include <config.h>
30 #else
31 # if !defined __STDC__ || !__STDC__
32 /* This is a separate conditional since some stdc systems
33    reject `defined (const)'.  */
34 #  ifndef const
35 #   define const
36 #  endif
37 # endif
38 #endif
39
40 #include <stdio.h>
41
42 /* Comment out all this code if we are using the GNU C Library, and are not
43    actually compiling the library itself.  This code is part of the GNU C
44    Library, but also included in many other GNU distributions.  Compiling
45    and linking in this code is a waste when using the GNU C library
46    (especially if it is a shared library).  Rather than having every GNU
47    program understand `configure --with-gnu-libc' and omit the object files,
48    it is simpler to just do this in the source for each such file.  */
49
50 #define GETOPT_INTERFACE_VERSION 2
51 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
52 # include <gnu-versions.h>
53 # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
54 #  define ELIDE_CODE
55 # endif
56 #endif
57
58 #ifndef ELIDE_CODE
59
60
61 /* This needs to come after some library #include
62    to get __GNU_LIBRARY__ defined.  */
63 #ifdef  __GNU_LIBRARY__
64 /* Don't include stdlib.h for non-GNU C libraries because some of them
65    contain conflicting prototypes for getopt.  */
66 # include <stdlib.h>
67 # include <unistd.h>
68 #endif  /* GNU C library.  */
69
70 #ifdef VMS
71 # include <unixlib.h>
72 # if HAVE_STRING_H - 0
73 #  include <string.h>
74 # endif
75 #endif
76
77 #ifndef _
78 /* This is for other GNU distributions with internationalized messages.
79    When compiling libc, the _ macro is predefined.  */
80 # ifdef HAVE_LIBINTL_H
81 #  include <libintl.h>
82 #  define _(msgid)      gettext (msgid)
83 # else
84 #  define _(msgid)      (msgid)
85 # endif
86 #endif
87
88 /* This version of `getopt' appears to the caller like standard Unix `getopt'
89    but it behaves differently for the user, since it allows the user
90    to intersperse the options with the other arguments.
91
92    As `getopt' works, it permutes the elements of ARGV so that,
93    when it is done, all the options precede everything else.  Thus
94    all application programs are extended to handle flexible argument order.
95
96    Setting the environment variable POSIXLY_CORRECT disables permutation.
97    Then the behavior is completely standard.
98
99    GNU application programs can use a third alternative mode in which
100    they can distinguish the relative order of options and other arguments.  */
101
102 #include "getopt.h"
103
104 /* For communication from `getopt' to the caller.
105    When `getopt' finds an option that takes an argument,
106    the argument value is returned here.
107    Also, when `ordering' is RETURN_IN_ORDER,
108    each non-option ARGV-element is returned here.  */
109
110 char *optarg;
111
112 /* Index in ARGV of the next element to be scanned.
113    This is used for communication to and from the caller
114    and for communication between successive calls to `getopt'.
115
116    On entry to `getopt', zero means this is the first call; initialize.
117
118    When `getopt' returns -1, this is the index of the first of the
119    non-option elements that the caller should itself scan.
120
121    Otherwise, `optind' communicates from one call to the next
122    how much of ARGV has been scanned so far.  */
123
124 /* 1003.2 says this must be 1 before any call.  */
125 int optind = 1;
126
127 /* Formerly, initialization of getopt depended on optind==0, which
128    causes problems with re-calling getopt as programs generally don't
129    know that. */
130
131 int __getopt_initialized;
132
133 /* The next char to be scanned in the option-element
134    in which the last option character we returned was found.
135    This allows us to pick up the scan where we left off.
136
137    If this is zero, or a null string, it means resume the scan
138    by advancing to the next ARGV-element.  */
139
140 static char *nextchar;
141
142 /* Callers store zero here to inhibit the error message
143    for unrecognized options.  */
144
145 int opterr = 1;
146
147 /* Set to an option character which was unrecognized.
148    This must be initialized on some systems to avoid linking in the
149    system's own getopt implementation.  */
150
151 int optopt = '?';
152
153 /* Describe how to deal with options that follow non-option ARGV-elements.
154
155    If the caller did not specify anything,
156    the default is REQUIRE_ORDER if the environment variable
157    POSIXLY_CORRECT is defined, PERMUTE otherwise.
158
159    REQUIRE_ORDER means don't recognize them as options;
160    stop option processing when the first non-option is seen.
161    This is what Unix does.
162    This mode of operation is selected by either setting the environment
163    variable POSIXLY_CORRECT, or using `+' as the first character
164    of the list of option characters.
165
166    PERMUTE is the default.  We permute the contents of ARGV as we scan,
167    so that eventually all the non-options are at the end.  This allows options
168    to be given in any order, even with programs that were not written to
169    expect this.
170
171    RETURN_IN_ORDER is an option available to programs that were written
172    to expect options and other ARGV-elements in any order and that care about
173    the ordering of the two.  We describe each non-option ARGV-element
174    as if it were the argument of an option with character code 1.
175    Using `-' as the first character of the list of option characters
176    selects this mode of operation.
177
178    The special argument `--' forces an end of option-scanning regardless
179    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
180    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
181
182 static enum
183 {
184   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
185 } ordering;
186
187 /* Value of POSIXLY_CORRECT environment variable.  */
188 static char *posixly_correct;
189 \f
190 #ifdef  __GNU_LIBRARY__
191 /* We want to avoid inclusion of string.h with non-GNU libraries
192    because there are many ways it can cause trouble.
193    On some systems, it contains special magic macros that don't work
194    in GCC.  */
195 # include <string.h>
196 # define my_index       strchr
197 #else
198
199 # if HAVE_STRING_H
200 #  include <string.h>
201 # else
202 #  include <strings.h>
203 # endif
204
205 /* Avoid depending on library functions or files
206    whose names are inconsistent.  */
207
208 #ifndef getenv
209 extern char *getenv ();
210 #endif
211
212 static char *
213 my_index (str, chr)
214      const char *str;
215      int chr;
216 {
217   while (*str)
218     {
219       if (*str == chr)
220         return (char *) str;
221       str++;
222     }
223   return 0;
224 }
225
226 /* If using GCC, we can safely declare strlen this way.
227    If not using GCC, it is ok not to declare it.  */
228 #ifdef __GNUC__
229 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
230    That was relevant to code that was here before.  */
231 # if (!defined __STDC__ || !__STDC__) && !defined strlen
232 /* gcc with -traditional declares the built-in strlen to return int,
233    and has done so at least since version 2.4.5. -- rms.  */
234 extern int strlen (const char *);
235 # endif /* not __STDC__ */
236 #endif /* __GNUC__ */
237
238 #endif /* not __GNU_LIBRARY__ */
239 \f
240 /* Handle permutation of arguments.  */
241
242 /* Describe the part of ARGV that contains non-options that have
243    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
244    `last_nonopt' is the index after the last of them.  */
245
246 static int first_nonopt;
247 static int last_nonopt;
248
249 #ifdef _LIBC
250 /* Bash 2.0 gives us an environment variable containing flags
251    indicating ARGV elements that should not be considered arguments.  */
252
253 /* Defined in getopt_init.c  */
254 extern char *__getopt_nonoption_flags;
255
256 static int nonoption_flags_max_len;
257 static int nonoption_flags_len;
258
259 static int original_argc;
260 static char *const *original_argv;
261
262 /* Make sure the environment variable bash 2.0 puts in the environment
263    is valid for the getopt call we must make sure that the ARGV passed
264    to getopt is that one passed to the process.  */
265 static void
266 __attribute__ ((unused))
267 store_args_and_env (int argc, char *const *argv)
268 {
269   /* XXX This is no good solution.  We should rather copy the args so
270      that we can compare them later.  But we must not use malloc(3).  */
271   original_argc = argc;
272   original_argv = argv;
273 }
274 # ifdef text_set_element
275 text_set_element (__libc_subinit, store_args_and_env);
276 # endif /* text_set_element */
277
278 # define SWAP_FLAGS(ch1, ch2) \
279   if (nonoption_flags_len > 0)                                                \
280     {                                                                         \
281       char __tmp = __getopt_nonoption_flags[ch1];                             \
282       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
283       __getopt_nonoption_flags[ch2] = __tmp;                                  \
284     }
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 #ifdef _LIBC
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 #ifdef _LIBC
421   if (posixly_correct == NULL
422       && argc == original_argc && argv == original_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 \f
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   optarg = NULL;
519
520   if (optind == 0 || !__getopt_initialized)
521     {
522       if (optind == 0)
523         optind = 1;     /* Don't scan ARGV[0], the program name.  */
524       optstring = _getopt_initialize (argc, argv, optstring);
525       __getopt_initialized = 1;
526     }
527
528   /* Test whether ARGV[optind] points to a non-option argument.
529      Either it does not have option syntax, or there is an environment flag
530      from the shell indicating it is not an option.  The later information
531      is only used when the used in the GNU libc.  */
532 #ifdef _LIBC
533 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
534                       || (optind < nonoption_flags_len                        \
535                           && __getopt_nonoption_flags[optind] == '1'))
536 #else
537 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
538 #endif
539
540   if (nextchar == NULL || *nextchar == '\0')
541     {
542       /* Advance to the next ARGV-element.  */
543
544       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
545          moved back by the user (who may also have changed the arguments).  */
546       if (last_nonopt > optind)
547         last_nonopt = optind;
548       if (first_nonopt > optind)
549         first_nonopt = optind;
550
551       if (ordering == PERMUTE)
552         {
553           /* If we have just processed some options following some non-options,
554              exchange them so that the options come first.  */
555
556           if (first_nonopt != last_nonopt && last_nonopt != optind)
557             exchange ((char **) argv);
558           else if (last_nonopt != optind)
559             first_nonopt = optind;
560
561           /* Skip any additional non-options
562              and extend the range of non-options previously skipped.  */
563
564           while (optind < argc && NONOPTION_P)
565             optind++;
566           last_nonopt = optind;
567         }
568
569       /* The special ARGV-element `--' means premature end of options.
570          Skip it like a null option,
571          then exchange with previous non-options as if it were an option,
572          then skip everything else like a non-option.  */
573
574       if (optind != argc && !strcmp (argv[optind], "--"))
575         {
576           optind++;
577
578           if (first_nonopt != last_nonopt && last_nonopt != optind)
579             exchange ((char **) argv);
580           else if (first_nonopt == last_nonopt)
581             first_nonopt = optind;
582           last_nonopt = argc;
583
584           optind = argc;
585         }
586
587       /* If we have done all the ARGV-elements, stop the scan
588          and back over any non-options that we skipped and permuted.  */
589
590       if (optind == argc)
591         {
592           /* Set the next-arg-index to point at the non-options
593              that we previously skipped, so the caller will digest them.  */
594           if (first_nonopt != last_nonopt)
595             optind = first_nonopt;
596           return -1;
597         }
598
599       /* If we have come to a non-option and did not permute it,
600          either stop the scan or describe it to the caller and pass it by.  */
601
602       if (NONOPTION_P)
603         {
604           if (ordering == REQUIRE_ORDER)
605             return -1;
606           optarg = argv[optind++];
607           return 1;
608         }
609
610       /* We have found another option-ARGV-element.
611          Skip the initial punctuation.  */
612
613       nextchar = (argv[optind] + 1
614                   + (longopts != NULL && argv[optind][1] == '-'));
615     }
616
617   /* Decode the current option-ARGV-element.  */
618
619   /* Check whether the ARGV-element is a long option.
620
621      If long_only and the ARGV-element has the form "-f", where f is
622      a valid short option, don't consider it an abbreviated form of
623      a long option that starts with f.  Otherwise there would be no
624      way to give the -f short option.
625
626      On the other hand, if there's a long option "fubar" and
627      the ARGV-element is "-fu", do consider that an abbreviation of
628      the long option, just like "--fu", and not "-f" with arg "u".
629
630      This distinction seems to be the most useful approach.  */
631
632   if (longopts != NULL
633       && (argv[optind][1] == '-'
634           || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
635     {
636       char *nameend;
637       const struct option *p;
638       const struct option *pfound = NULL;
639       int exact = 0;
640       int ambig = 0;
641       int indfound = -1;
642       int option_index;
643
644       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
645         /* Do nothing.  */ ;
646
647       /* Test all long options for either exact match
648          or abbreviated matches.  */
649       for (p = longopts, option_index = 0; p->name; p++, option_index++)
650         if (!strncmp (p->name, nextchar, nameend - nextchar))
651           {
652             if ((unsigned int) (nameend - nextchar)
653                 == (unsigned int) strlen (p->name))
654               {
655                 /* Exact match found.  */
656                 pfound = p;
657                 indfound = option_index;
658                 exact = 1;
659                 break;
660               }
661             else if (pfound == NULL)
662               {
663                 /* First nonexact match found.  */
664                 pfound = p;
665                 indfound = option_index;
666               }
667             else
668               /* Second or later nonexact match found.  */
669               ambig = 1;
670           }
671
672       if (ambig && !exact)
673         {
674           if (opterr)
675             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
676                      argv[0], argv[optind]);
677           nextchar += strlen (nextchar);
678           optind++;
679           optopt = 0;
680           return '?';
681         }
682
683       if (pfound != NULL)
684         {
685           option_index = indfound;
686           optind++;
687           if (*nameend)
688             {
689               /* Don't test has_arg with >, because some C compilers don't
690                  allow it to be used on enums.  */
691               if (pfound->has_arg)
692                 optarg = nameend + 1;
693               else
694                 {
695                   if (opterr)
696                     {
697                       if (argv[optind - 1][1] == '-')
698                         /* --option */
699                         fprintf (stderr,
700                                  _("%s: option `--%s' doesn't allow an argument\n"),
701                                  argv[0], pfound->name);
702                       else
703                         /* +option or -option */
704                         fprintf (stderr,
705                                  _("%s: option `%c%s' doesn't allow an argument\n"),
706                                  argv[0], argv[optind - 1][0], pfound->name);
707                     }
708
709                   nextchar += strlen (nextchar);
710
711                   optopt = pfound->val;
712                   return '?';
713                 }
714             }
715           else if (pfound->has_arg == 1)
716             {
717               if (optind < argc)
718                 optarg = argv[optind++];
719               else
720                 {
721                   if (opterr)
722                     fprintf (stderr,
723                            _("%s: option `%s' requires an argument\n"),
724                            argv[0], argv[optind - 1]);
725                   nextchar += strlen (nextchar);
726                   optopt = pfound->val;
727                   return optstring[0] == ':' ? ':' : '?';
728                 }
729             }
730           nextchar += strlen (nextchar);
731           if (longind != NULL)
732             *longind = option_index;
733           if (pfound->flag)
734             {
735               *(pfound->flag) = pfound->val;
736               return 0;
737             }
738           return pfound->val;
739         }
740
741       /* Can't find it as a long option.  If this is not getopt_long_only,
742          or the option starts with '--' or is not a valid short
743          option, then it's an error.
744          Otherwise interpret it as a short option.  */
745       if (!long_only || argv[optind][1] == '-'
746           || my_index (optstring, *nextchar) == NULL)
747         {
748           if (opterr)
749             {
750               if (argv[optind][1] == '-')
751                 /* --option */
752                 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
753                          argv[0], nextchar);
754               else
755                 /* +option or -option */
756                 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
757                          argv[0], argv[optind][0], nextchar);
758             }
759           nextchar = (char *) "";
760           optind++;
761           optopt = 0;
762           return '?';
763         }
764     }
765
766   /* Look at and handle the next short option-character.  */
767
768   {
769     char c = *nextchar++;
770     char *temp = my_index (optstring, c);
771
772     /* Increment `optind' when we start to process its last character.  */
773     if (*nextchar == '\0')
774       ++optind;
775
776     if (temp == NULL || c == ':')
777       {
778         if (opterr)
779           {
780             if (posixly_correct)
781               /* 1003.2 specifies the format of this message.  */
782               fprintf (stderr, _("%s: illegal option -- %c\n"),
783                        argv[0], c);
784             else
785               fprintf (stderr, _("%s: invalid option -- %c\n"),
786                        argv[0], c);
787           }
788         optopt = c;
789         return '?';
790       }
791     /* Convenience. Treat POSIX -W foo same as long option --foo */
792     if (temp[0] == 'W' && temp[1] == ';')
793       {
794         char *nameend;
795         const struct option *p;
796         const struct option *pfound = NULL;
797         int exact = 0;
798         int ambig = 0;
799         int indfound = 0;
800         int option_index;
801
802         /* This is an option that requires an argument.  */
803         if (*nextchar != '\0')
804           {
805             optarg = nextchar;
806             /* If we end this ARGV-element by taking the rest as an arg,
807                we must advance to the next element now.  */
808             optind++;
809           }
810         else if (optind == argc)
811           {
812             if (opterr)
813               {
814                 /* 1003.2 specifies the format of this message.  */
815                 fprintf (stderr, _("%s: option requires an argument -- %c\n"),
816                          argv[0], c);
817               }
818             optopt = c;
819             if (optstring[0] == ':')
820               c = ':';
821             else
822               c = '?';
823             return c;
824           }
825         else
826           /* We already incremented `optind' once;
827              increment it again when taking next ARGV-elt as argument.  */
828           optarg = argv[optind++];
829
830         /* optarg is now the argument, see if it's in the
831            table of longopts.  */
832
833         for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
834           /* Do nothing.  */ ;
835
836         /* Test all long options for either exact match
837            or abbreviated matches.  */
838         for (p = longopts, option_index = 0; p->name; p++, option_index++)
839           if (!strncmp (p->name, nextchar, nameend - nextchar))
840             {
841               if ((unsigned int) (nameend - nextchar) == strlen (p->name))
842                 {
843                   /* Exact match found.  */
844                   pfound = p;
845                   indfound = option_index;
846                   exact = 1;
847                   break;
848                 }
849               else if (pfound == NULL)
850                 {
851                   /* First nonexact match found.  */
852                   pfound = p;
853                   indfound = option_index;
854                 }
855               else
856                 /* Second or later nonexact match found.  */
857                 ambig = 1;
858             }
859         if (ambig && !exact)
860           {
861             if (opterr)
862               fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
863                        argv[0], argv[optind]);
864             nextchar += strlen (nextchar);
865             optind++;
866             return '?';
867           }
868         if (pfound != NULL)
869           {
870             option_index = indfound;
871             if (*nameend)
872               {
873                 /* Don't test has_arg with >, because some C compilers don't
874                    allow it to be used on enums.  */
875                 if (pfound->has_arg)
876                   optarg = nameend + 1;
877                 else
878                   {
879                     if (opterr)
880                       fprintf (stderr, _("\
881 %s: option `-W %s' doesn't allow an argument\n"),
882                                argv[0], pfound->name);
883
884                     nextchar += strlen (nextchar);
885                     return '?';
886                   }
887               }
888             else if (pfound->has_arg == 1)
889               {
890                 if (optind < argc)
891                   optarg = argv[optind++];
892                 else
893                   {
894                     if (opterr)
895                       fprintf (stderr,
896                                _("%s: option `%s' requires an argument\n"),
897                                argv[0], argv[optind - 1]);
898                     nextchar += strlen (nextchar);
899                     return optstring[0] == ':' ? ':' : '?';
900                   }
901               }
902             nextchar += strlen (nextchar);
903             if (longind != NULL)
904               *longind = option_index;
905             if (pfound->flag)
906               {
907                 *(pfound->flag) = pfound->val;
908                 return 0;
909               }
910             return pfound->val;
911           }
912           nextchar = NULL;
913           return 'W';   /* Let the application handle it.   */
914       }
915     if (temp[1] == ':')
916       {
917         if (temp[2] == ':')
918           {
919             /* This is an option that accepts an argument optionally.  */
920             if (*nextchar != '\0')
921               {
922                 optarg = nextchar;
923                 optind++;
924               }
925             else
926               optarg = NULL;
927             nextchar = NULL;
928           }
929         else
930           {
931             /* This is an option that requires an argument.  */
932             if (*nextchar != '\0')
933               {
934                 optarg = nextchar;
935                 /* If we end this ARGV-element by taking the rest as an arg,
936                    we must advance to the next element now.  */
937                 optind++;
938               }
939             else if (optind == argc)
940               {
941                 if (opterr)
942                   {
943                     /* 1003.2 specifies the format of this message.  */
944                     fprintf (stderr,
945                            _("%s: option requires an argument -- %c\n"),
946                            argv[0], c);
947                   }
948                 optopt = c;
949                 if (optstring[0] == ':')
950                   c = ':';
951                 else
952                   c = '?';
953               }
954             else
955               /* We already incremented `optind' once;
956                  increment it again when taking next ARGV-elt as argument.  */
957               optarg = argv[optind++];
958             nextchar = NULL;
959           }
960       }
961     return c;
962   }
963 }
964
965 int
966 getopt (argc, argv, optstring)
967      int argc;
968      char *const *argv;
969      const char *optstring;
970 {
971   return _getopt_internal (argc, argv, optstring,
972                            (const struct option *) 0,
973                            (int *) 0,
974                            0);
975 }
976
977 #endif  /* Not ELIDE_CODE.  */
978 \f
979 #ifdef TEST
980
981 /* Compile with -DTEST to make an executable for use in testing
982    the above definition of `getopt'.  */
983
984 int
985 main (argc, argv)
986      int argc;
987      char **argv;
988 {
989   int c;
990   int digit_optind = 0;
991
992   while (1)
993     {
994       int this_option_optind = optind ? optind : 1;
995
996       c = getopt (argc, argv, "abc:d:0123456789");
997       if (c == -1)
998         break;
999
1000       switch (c)
1001         {
1002         case '0':
1003         case '1':
1004         case '2':
1005         case '3':
1006         case '4':
1007         case '5':
1008         case '6':
1009         case '7':
1010         case '8':
1011         case '9':
1012           if (digit_optind != 0 && digit_optind != this_option_optind)
1013             printf ("digits occur in two different argv-elements.\n");
1014           digit_optind = this_option_optind;
1015           printf ("option %c\n", c);
1016           break;
1017
1018         case 'a':
1019           printf ("option a\n");
1020           break;
1021
1022         case 'b':
1023           printf ("option b\n");
1024           break;
1025
1026         case 'c':
1027           printf ("option c with value `%s'\n", optarg);
1028           break;
1029
1030         case '?':
1031           break;
1032
1033         default:
1034           printf ("?? getopt returned character code 0%o ??\n", c);
1035         }
1036     }
1037
1038   if (optind < argc)
1039     {
1040       printf ("non-option ARGV-elements: ");
1041       while (optind < argc)
1042         printf ("%s ", argv[optind++]);
1043       printf ("\n");
1044     }
1045
1046   exit (0);
1047 }
1048
1049 #endif /* TEST */