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