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