[!__GNU_LIBRARY__]: Include string.h or strings.h.
[kopensolaris-gnu/glibc.git] / posix / 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 # if HAVE_STRING_H
202 #  include <string.h>
203 # else
204 #  include <strings.h>
205 # endif
206
207 /* Avoid depending on library functions or files
208    whose names are inconsistent.  */
209
210 #ifndef getenv
211 extern char *getenv ();
212 #endif
213
214 static char *
215 my_index (str, chr)
216      const char *str;
217      int chr;
218 {
219   while (*str)
220     {
221       if (*str == chr)
222         return (char *) str;
223       str++;
224     }
225   return 0;
226 }
227
228 /* If using GCC, we can safely declare strlen this way.
229    If not using GCC, it is ok not to declare it.  */
230 #ifdef __GNUC__
231 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
232    That was relevant to code that was here before.  */
233 # if (!defined __STDC__ || !__STDC__) && !defined strlen
234 /* gcc with -traditional declares the built-in strlen to return int,
235    and has done so at least since version 2.4.5. -- rms.  */
236 extern int strlen (const char *);
237 # endif /* not __STDC__ */
238 #endif /* __GNUC__ */
239
240 #endif /* not __GNU_LIBRARY__ */
241 \f
242 /* Handle permutation of arguments.  */
243
244 /* Describe the part of ARGV that contains non-options that have
245    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
246    `last_nonopt' is the index after the last of them.  */
247
248 static int first_nonopt;
249 static int last_nonopt;
250
251 #ifdef _LIBC
252 /* Bash 2.0 gives us an environment variable containing flags
253    indicating ARGV elements that should not be considered arguments.  */
254
255 /* Defined in getopt_init.c  */
256 extern char *__getopt_nonoption_flags;
257
258 static int nonoption_flags_max_len;
259 static int nonoption_flags_len;
260
261 static int original_argc;
262 static char *const *original_argv;
263
264 /* Make sure the environment variable bash 2.0 puts in the environment
265    is valid for the getopt call we must make sure that the ARGV passed
266    to getopt is that one passed to the process.  */
267 static void
268 __attribute__ ((unused))
269 store_args_and_env (int argc, char *const *argv)
270 {
271   /* XXX This is no good solution.  We should rather copy the args so
272      that we can compare them later.  But we must not use malloc(3).  */
273   original_argc = argc;
274   original_argv = argv;
275 }
276 # ifdef text_set_element
277 text_set_element (__libc_subinit, store_args_and_env);
278 # endif /* text_set_element */
279
280 # define SWAP_FLAGS(ch1, ch2) \
281   if (nonoption_flags_len > 0)                                                \
282     {                                                                         \
283       char __tmp = __getopt_nonoption_flags[ch1];                             \
284       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
285       __getopt_nonoption_flags[ch2] = __tmp;                                  \
286     }
287 #else   /* !_LIBC */
288 # define SWAP_FLAGS(ch1, ch2)
289 #endif  /* _LIBC */
290
291 /* Exchange two adjacent subsequences of ARGV.
292    One subsequence is elements [first_nonopt,last_nonopt)
293    which contains all the non-options that have been skipped so far.
294    The other is elements [last_nonopt,optind), which contains all
295    the options processed since those non-options were skipped.
296
297    `first_nonopt' and `last_nonopt' are relocated so that they describe
298    the new indices of the non-options in ARGV after they are moved.  */
299
300 #if defined __STDC__ && __STDC__
301 static void exchange (char **);
302 #endif
303
304 static void
305 exchange (argv)
306      char **argv;
307 {
308   int bottom = first_nonopt;
309   int middle = last_nonopt;
310   int top = optind;
311   char *tem;
312
313   /* Exchange the shorter segment with the far end of the longer segment.
314      That puts the shorter segment into the right place.
315      It leaves the longer segment in the right place overall,
316      but it consists of two parts that need to be swapped next.  */
317
318 #ifdef _LIBC
319   /* First make sure the handling of the `__getopt_nonoption_flags'
320      string can work normally.  Our top argument must be in the range
321      of the string.  */
322   if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
323     {
324       /* We must extend the array.  The user plays games with us and
325          presents new arguments.  */
326       char *new_str = malloc (top + 1);
327       if (new_str == NULL)
328         nonoption_flags_len = nonoption_flags_max_len = 0;
329       else
330         {
331           memset (__mempcpy (new_str, __getopt_nonoption_flags,
332                              nonoption_flags_max_len),
333                   '\0', top + 1 - nonoption_flags_max_len);
334           nonoption_flags_max_len = top + 1;
335           __getopt_nonoption_flags = new_str;
336         }
337     }
338 #endif
339
340   while (top > middle && middle > bottom)
341     {
342       if (top - middle > middle - bottom)
343         {
344           /* Bottom segment is the short one.  */
345           int len = middle - bottom;
346           register int i;
347
348           /* Swap it with the top part of the top segment.  */
349           for (i = 0; i < len; i++)
350             {
351               tem = argv[bottom + i];
352               argv[bottom + i] = argv[top - (middle - bottom) + i];
353               argv[top - (middle - bottom) + i] = tem;
354               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
355             }
356           /* Exclude the moved bottom segment from further swapping.  */
357           top -= len;
358         }
359       else
360         {
361           /* Top segment is the short one.  */
362           int len = top - middle;
363           register int i;
364
365           /* Swap it with the bottom part of the bottom segment.  */
366           for (i = 0; i < len; i++)
367             {
368               tem = argv[bottom + i];
369               argv[bottom + i] = argv[middle + i];
370               argv[middle + i] = tem;
371               SWAP_FLAGS (bottom + i, middle + i);
372             }
373           /* Exclude the moved top segment from further swapping.  */
374           bottom += len;
375         }
376     }
377
378   /* Update records for the slots the non-options now occupy.  */
379
380   first_nonopt += (optind - last_nonopt);
381   last_nonopt = optind;
382 }
383
384 /* Initialize the internal data when the first call is made.  */
385
386 #if defined __STDC__ && __STDC__
387 static const char *_getopt_initialize (int, char *const *, const char *);
388 #endif
389 static const char *
390 _getopt_initialize (argc, argv, optstring)
391      int argc;
392      char *const *argv;
393      const char *optstring;
394 {
395   /* Start processing options with ARGV-element 1 (since ARGV-element 0
396      is the program name); the sequence of previously skipped
397      non-option ARGV-elements is empty.  */
398
399   first_nonopt = last_nonopt = optind;
400
401   nextchar = NULL;
402
403   posixly_correct = getenv ("POSIXLY_CORRECT");
404
405   /* Determine how to handle the ordering of options and nonoptions.  */
406
407   if (optstring[0] == '-')
408     {
409       ordering = RETURN_IN_ORDER;
410       ++optstring;
411     }
412   else if (optstring[0] == '+')
413     {
414       ordering = REQUIRE_ORDER;
415       ++optstring;
416     }
417   else if (posixly_correct != NULL)
418     ordering = REQUIRE_ORDER;
419   else
420     ordering = PERMUTE;
421
422 #ifdef _LIBC
423   if (posixly_correct == NULL
424       && argc == original_argc && argv == original_argv)
425     {
426       if (nonoption_flags_max_len == 0)
427         {
428           if (__getopt_nonoption_flags == NULL
429               || __getopt_nonoption_flags[0] == '\0')
430             nonoption_flags_max_len = -1;
431           else
432             {
433               const char *orig_str = __getopt_nonoption_flags;
434               int len = nonoption_flags_max_len = strlen (orig_str);
435               if (nonoption_flags_max_len < argc)
436                 nonoption_flags_max_len = argc;
437               __getopt_nonoption_flags =
438                 (char *) malloc (nonoption_flags_max_len);
439               if (__getopt_nonoption_flags == NULL)
440                 nonoption_flags_max_len = -1;
441               else
442                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
443                         '\0', nonoption_flags_max_len - len);
444             }
445         }
446       nonoption_flags_len = nonoption_flags_max_len;
447     }
448   else
449     nonoption_flags_len = 0;
450 #endif
451
452   return optstring;
453 }
454 \f
455 /* Scan elements of ARGV (whose length is ARGC) for option characters
456    given in OPTSTRING.
457
458    If an element of ARGV starts with '-', and is not exactly "-" or "--",
459    then it is an option element.  The characters of this element
460    (aside from the initial '-') are option characters.  If `getopt'
461    is called repeatedly, it returns successively each of the option characters
462    from each of the option elements.
463
464    If `getopt' finds another option character, it returns that character,
465    updating `optind' and `nextchar' so that the next call to `getopt' can
466    resume the scan with the following option character or ARGV-element.
467
468    If there are no more option characters, `getopt' returns -1.
469    Then `optind' is the index in ARGV of the first ARGV-element
470    that is not an option.  (The ARGV-elements have been permuted
471    so that those that are not options now come last.)
472
473    OPTSTRING is a string containing the legitimate option characters.
474    If an option character is seen that is not listed in OPTSTRING,
475    return '?' after printing an error message.  If you set `opterr' to
476    zero, the error message is suppressed but we still return '?'.
477
478    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
479    so the following text in the same ARGV-element, or the text of the following
480    ARGV-element, is returned in `optarg'.  Two colons mean an option that
481    wants an optional arg; if there is text in the current ARGV-element,
482    it is returned in `optarg', otherwise `optarg' is set to zero.
483
484    If OPTSTRING starts with `-' or `+', it requests different methods of
485    handling the non-option ARGV-elements.
486    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
487
488    Long-named options begin with `--' instead of `-'.
489    Their names may be abbreviated as long as the abbreviation is unique
490    or is an exact match for some defined option.  If they have an
491    argument, it follows the option name in the same ARGV-element, separated
492    from the option name by a `=', or else the in next ARGV-element.
493    When `getopt' finds a long-named option, it returns 0 if that option's
494    `flag' field is nonzero, the value of the option's `val' field
495    if the `flag' field is zero.
496
497    The elements of ARGV aren't really const, because we permute them.
498    But we pretend they're const in the prototype to be compatible
499    with other systems.
500
501    LONGOPTS is a vector of `struct option' terminated by an
502    element containing a name which is zero.
503
504    LONGIND returns the index in LONGOPT of the long-named option found.
505    It is only valid when a long-named option has been found by the most
506    recent call.
507
508    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
509    long-named options.  */
510
511 int
512 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
513      int argc;
514      char *const *argv;
515      const char *optstring;
516      const struct option *longopts;
517      int *longind;
518      int long_only;
519 {
520   optarg = NULL;
521
522   if (optind == 0 || !__getopt_initialized)
523     {
524       if (optind == 0)
525         optind = 1;     /* Don't scan ARGV[0], the program name.  */
526       optstring = _getopt_initialize (argc, argv, optstring);
527       __getopt_initialized = 1;
528     }
529
530   /* Test whether ARGV[optind] points to a non-option argument.
531      Either it does not have option syntax, or there is an environment flag
532      from the shell indicating it is not an option.  The later information
533      is only used when the used in the GNU libc.  */
534 #ifdef _LIBC
535 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
536                       || (optind < nonoption_flags_len                        \
537                           && __getopt_nonoption_flags[optind] == '1'))
538 #else
539 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
540 #endif
541
542   if (nextchar == NULL || *nextchar == '\0')
543     {
544       /* Advance to the next ARGV-element.  */
545
546       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
547          moved back by the user (who may also have changed the arguments).  */
548       if (last_nonopt > optind)
549         last_nonopt = optind;
550       if (first_nonopt > optind)
551         first_nonopt = optind;
552
553       if (ordering == PERMUTE)
554         {
555           /* If we have just processed some options following some non-options,
556              exchange them so that the options come first.  */
557
558           if (first_nonopt != last_nonopt && last_nonopt != optind)
559             exchange ((char **) argv);
560           else if (last_nonopt != optind)
561             first_nonopt = optind;
562
563           /* Skip any additional non-options
564              and extend the range of non-options previously skipped.  */
565
566           while (optind < argc && NONOPTION_P)
567             optind++;
568           last_nonopt = optind;
569         }
570
571       /* The special ARGV-element `--' means premature end of options.
572          Skip it like a null option,
573          then exchange with previous non-options as if it were an option,
574          then skip everything else like a non-option.  */
575
576       if (optind != argc && !strcmp (argv[optind], "--"))
577         {
578           optind++;
579
580           if (first_nonopt != last_nonopt && last_nonopt != optind)
581             exchange ((char **) argv);
582           else if (first_nonopt == last_nonopt)
583             first_nonopt = optind;
584           last_nonopt = argc;
585
586           optind = argc;
587         }
588
589       /* If we have done all the ARGV-elements, stop the scan
590          and back over any non-options that we skipped and permuted.  */
591
592       if (optind == argc)
593         {
594           /* Set the next-arg-index to point at the non-options
595              that we previously skipped, so the caller will digest them.  */
596           if (first_nonopt != last_nonopt)
597             optind = first_nonopt;
598           return -1;
599         }
600
601       /* If we have come to a non-option and did not permute it,
602          either stop the scan or describe it to the caller and pass it by.  */
603
604       if (NONOPTION_P)
605         {
606           if (ordering == REQUIRE_ORDER)
607             return -1;
608           optarg = argv[optind++];
609           return 1;
610         }
611
612       /* We have found another option-ARGV-element.
613          Skip the initial punctuation.  */
614
615       nextchar = (argv[optind] + 1
616                   + (longopts != NULL && argv[optind][1] == '-'));
617     }
618
619   /* Decode the current option-ARGV-element.  */
620
621   /* Check whether the ARGV-element is a long option.
622
623      If long_only and the ARGV-element has the form "-f", where f is
624      a valid short option, don't consider it an abbreviated form of
625      a long option that starts with f.  Otherwise there would be no
626      way to give the -f short option.
627
628      On the other hand, if there's a long option "fubar" and
629      the ARGV-element is "-fu", do consider that an abbreviation of
630      the long option, just like "--fu", and not "-f" with arg "u".
631
632      This distinction seems to be the most useful approach.  */
633
634   if (longopts != NULL
635       && (argv[optind][1] == '-'
636           || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
637     {
638       char *nameend;
639       const struct option *p;
640       const struct option *pfound = NULL;
641       int exact = 0;
642       int ambig = 0;
643       int indfound = -1;
644       int option_index;
645
646       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
647         /* Do nothing.  */ ;
648
649       /* Test all long options for either exact match
650          or abbreviated matches.  */
651       for (p = longopts, option_index = 0; p->name; p++, option_index++)
652         if (!strncmp (p->name, nextchar, nameend - nextchar))
653           {
654             if ((unsigned int) (nameend - nextchar)
655                 == (unsigned int) strlen (p->name))
656               {
657                 /* Exact match found.  */
658                 pfound = p;
659                 indfound = option_index;
660                 exact = 1;
661                 break;
662               }
663             else if (pfound == NULL)
664               {
665                 /* First nonexact match found.  */
666                 pfound = p;
667                 indfound = option_index;
668               }
669             else
670               /* Second or later nonexact match found.  */
671               ambig = 1;
672           }
673
674       if (ambig && !exact)
675         {
676           if (opterr)
677             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
678                      argv[0], argv[optind]);
679           nextchar += strlen (nextchar);
680           optind++;
681           optopt = 0;
682           return '?';
683         }
684
685       if (pfound != NULL)
686         {
687           option_index = indfound;
688           optind++;
689           if (*nameend)
690             {
691               /* Don't test has_arg with >, because some C compilers don't
692                  allow it to be used on enums.  */
693               if (pfound->has_arg)
694                 optarg = nameend + 1;
695               else
696                 {
697                   if (opterr)
698                    if (argv[optind - 1][1] == '-')
699                     /* --option */
700                     fprintf (stderr,
701                      _("%s: option `--%s' doesn't allow an argument\n"),
702                      argv[0], pfound->name);
703                    else
704                     /* +option or -option */
705                     fprintf (stderr,
706                      _("%s: option `%c%s' doesn't allow an argument\n"),
707                      argv[0], argv[optind - 1][0], pfound->name);
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 */