Release 2.14
[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->
704                                                                 name);
705                                                 else
706                                                         /* +option or -option */
707                                                         fprintf(stderr,
708                                                                 _
709                                                                 ("%s: option `%c%s' doesn't allow an argument\n"),
710                                                                 argv[0],
711                                                                 argv[optind
712                                                                      -
713                                                                      1][0],
714                                                                 pfound->
715                                                                 name);
716                                         }
717
718                                         nextchar += strlen(nextchar);
719
720                                         optopt = pfound->val;
721                                         return '?';
722                                 }
723                         } else if (pfound->has_arg == 1) {
724                                 if (optind < argc)
725                                         optarg = argv[optind++];
726                                 else {
727                                         if (print_errors)
728                                                 fprintf(stderr,
729                                                         _
730                                                         ("%s: option `%s' requires an argument\n"),
731                                                         argv[0],
732                                                         argv[optind - 1]);
733                                         nextchar += strlen(nextchar);
734                                         optopt = pfound->val;
735                                         return optstring[0] ==
736                                             ':' ? ':' : '?';
737                                 }
738                         }
739                         nextchar += strlen(nextchar);
740                         if (longind != NULL)
741                                 *longind = option_index;
742                         if (pfound->flag) {
743                                 *(pfound->flag) = pfound->val;
744                                 return 0;
745                         }
746                         return pfound->val;
747                 }
748
749                 /* Can't find it as a long option.  If this is not getopt_long_only,
750                    or the option starts with '--' or is not a valid short
751                    option, then it's an error.
752                    Otherwise interpret it as a short option.  */
753                 if (!long_only || argv[optind][1] == '-'
754                     || my_index(optstring, *nextchar) == NULL) {
755                         if (print_errors) {
756                                 if (argv[optind][1] == '-')
757                                         /* --option */
758                                         fprintf(stderr,
759                                                 _
760                                                 ("%s: unrecognized option `--%s'\n"),
761                                                 argv[0], nextchar);
762                                 else
763                                         /* +option or -option */
764                                         fprintf(stderr,
765                                                 _
766                                                 ("%s: unrecognized option `%c%s'\n"),
767                                                 argv[0], argv[optind][0],
768                                                 nextchar);
769                         }
770                         nextchar = (char *) "";
771                         optind++;
772                         optopt = 0;
773                         return '?';
774                 }
775         }
776
777         /* Look at and handle the next short option-character.  */
778
779         {
780                 char c = *nextchar++;
781                 char *temp = my_index(optstring, c);
782
783                 /* Increment `optind' when we start to process its last character.  */
784                 if (*nextchar == '\0')
785                         ++optind;
786
787                 if (temp == NULL || c == ':') {
788                         if (print_errors) {
789                                 if (posixly_correct)
790                                         /* 1003.2 specifies the format of this message.  */
791                                         fprintf(stderr,
792                                                 _
793                                                 ("%s: illegal option -- %c\n"),
794                                                 argv[0], c);
795                                 else
796                                         fprintf(stderr,
797                                                 _
798                                                 ("%s: invalid option -- %c\n"),
799                                                 argv[0], c);
800                         }
801                         optopt = c;
802                         return '?';
803                 }
804                 /* Convenience. Treat POSIX -W foo same as long option --foo */
805                 if (temp[0] == 'W' && temp[1] == ';') {
806                         char *nameend;
807                         const struct option *p;
808                         const struct option *pfound = NULL;
809                         int exact = 0;
810                         int ambig = 0;
811                         int indfound = 0;
812                         int option_index;
813
814                         /* This is an option that requires an argument.  */
815                         if (*nextchar != '\0') {
816                                 optarg = nextchar;
817                                 /* If we end this ARGV-element by taking the rest as an arg,
818                                    we must advance to the next element now.  */
819                                 optind++;
820                         } else if (optind == argc) {
821                                 if (print_errors) {
822                                         /* 1003.2 specifies the format of this message.  */
823                                         fprintf(stderr,
824                                                 _
825                                                 ("%s: option requires an argument -- %c\n"),
826                                                 argv[0], c);
827                                 }
828                                 optopt = c;
829                                 if (optstring[0] == ':')
830                                         c = ':';
831                                 else
832                                         c = '?';
833                                 return c;
834                         } else
835                                 /* We already incremented `optind' once;
836                                    increment it again when taking next ARGV-elt as argument.  */
837                                 optarg = argv[optind++];
838
839                         /* optarg is now the argument, see if it's in the
840                            table of longopts.  */
841
842                         for (nextchar = nameend = optarg;
843                              *nameend && *nameend != '='; nameend++)
844                                 /* Do nothing.  */ ;
845
846                         /* Test all long options for either exact match
847                            or abbreviated matches.  */
848                         for (p = longopts, option_index = 0; p->name;
849                              p++, option_index++)
850                                 if (!strncmp
851                                     (p->name, nextchar,
852                                      nameend - nextchar)) {
853                                         if ((unsigned int) (nameend -
854                                                             nextchar) ==
855                                             strlen(p->name)) {
856                                                 /* Exact match found.  */
857                                                 pfound = p;
858                                                 indfound = option_index;
859                                                 exact = 1;
860                                                 break;
861                                         } else if (pfound == NULL) {
862                                                 /* First nonexact match found.  */
863                                                 pfound = p;
864                                                 indfound = option_index;
865                                         } else
866                                                 /* Second or later nonexact match found.  */
867                                                 ambig = 1;
868                                 }
869                         if (ambig && !exact) {
870                                 if (print_errors)
871                                         fprintf(stderr,
872                                                 _
873                                                 ("%s: option `-W %s' is ambiguous\n"),
874                                                 argv[0], argv[optind]);
875                                 nextchar += strlen(nextchar);
876                                 optind++;
877                                 return '?';
878                         }
879                         if (pfound != NULL) {
880                                 option_index = indfound;
881                                 if (*nameend) {
882                                         /* Don't test has_arg with >, because some C compilers don't
883                                            allow it to be used on enums.  */
884                                         if (pfound->has_arg)
885                                                 optarg = nameend + 1;
886                                         else {
887                                                 if (print_errors)
888                                                         fprintf(stderr, _("\
889 %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->
890                                                                 name);
891
892                                                 nextchar +=
893                                                     strlen(nextchar);
894                                                 return '?';
895                                         }
896                                 } else if (pfound->has_arg == 1) {
897                                         if (optind < argc)
898                                                 optarg = argv[optind++];
899                                         else {
900                                                 if (print_errors)
901                                                         fprintf(stderr,
902                                                                 _
903                                                                 ("%s: option `%s' requires an argument\n"),
904                                                                 argv[0],
905                                                                 argv[optind
906                                                                      - 1]);
907                                                 nextchar +=
908                                                     strlen(nextchar);
909                                                 return optstring[0] ==
910                                                     ':' ? ':' : '?';
911                                         }
912                                 }
913                                 nextchar += strlen(nextchar);
914                                 if (longind != NULL)
915                                         *longind = option_index;
916                                 if (pfound->flag) {
917                                         *(pfound->flag) = pfound->val;
918                                         return 0;
919                                 }
920                                 return pfound->val;
921                         }
922                         nextchar = NULL;
923                         return 'W';     /* Let the application handle it.   */
924                 }
925                 if (temp[1] == ':') {
926                         if (temp[2] == ':') {
927                                 /* This is an option that accepts an argument optionally.  */
928                                 if (*nextchar != '\0') {
929                                         optarg = nextchar;
930                                         optind++;
931                                 } else
932                                         optarg = NULL;
933                                 nextchar = NULL;
934                         } else {
935                                 /* This is an option that requires an argument.  */
936                                 if (*nextchar != '\0') {
937                                         optarg = nextchar;
938                                         /* If we end this ARGV-element by taking the rest as an arg,
939                                            we must advance to the next element now.  */
940                                         optind++;
941                                 } else if (optind == argc) {
942                                         if (print_errors) {
943                                                 /* 1003.2 specifies the format of this message.  */
944                                                 fprintf(stderr,
945                                                         _
946                                                         ("%s: option requires an argument -- %c\n"),
947                                                         argv[0], c);
948                                         }
949                                         optopt = c;
950                                         if (optstring[0] == ':')
951                                                 c = ':';
952                                         else
953                                                 c = '?';
954                                 } else
955                                         /* We already incremented `optind' once;
956                                            increment it again when taking next ARGV-elt as argument.  */
957                                         optarg = argv[optind++];
958                                 nextchar = NULL;
959                         }
960                 }
961                 return c;
962         }
963 }
964
965 int getopt(argc, argv, optstring)
966 int argc;
967 char *const *argv;
968 const char *optstring;
969 {
970         return _getopt_internal(argc, argv, optstring,
971                                 (const struct option *) 0, (int *) 0, 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 main(argc, argv)
982 int argc;
983 char **argv;
984 {
985         int c;
986         int digit_optind = 0;
987
988         while (1) {
989                 int this_option_optind = optind ? optind : 1;
990
991                 c = getopt(argc, argv, "abc:d:0123456789");
992                 if (c == -1)
993                         break;
994
995                 switch (c) {
996                 case '0':
997                 case '1':
998                 case '2':
999                 case '3':
1000                 case '4':
1001                 case '5':
1002                 case '6':
1003                 case '7':
1004                 case '8':
1005                 case '9':
1006                         if (digit_optind != 0
1007                             && digit_optind != this_option_optind)
1008                                 printf
1009                                     ("digits occur in two different argv-elements.\n");
1010                         digit_optind = this_option_optind;
1011                         printf("option %c\n", c);
1012                         break;
1013
1014                 case 'a':
1015                         printf("option a\n");
1016                         break;
1017
1018                 case 'b':
1019                         printf("option b\n");
1020                         break;
1021
1022                 case 'c':
1023                         printf("option c with value `%s'\n", optarg);
1024                         break;
1025
1026                 case '?':
1027                         break;
1028
1029                 default:
1030                         printf
1031                             ("?? getopt returned character code 0%o ??\n",
1032                              c);
1033                 }
1034         }
1035
1036         if (optind < argc) {
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 */