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