Extract common logic in OpenSSL-specific code
[tinc] / 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 roland@gnu.ai.mit.edu
4    before changing it!
5
6    Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
7         Free Software Foundation, Inc.
8
9 NOTE: The canonical source of this file is maintained with the GNU C Library.
10 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
11
12 This program is free software; you can redistribute it and/or modify it
13 under the terms of the GNU General Public License as published by the
14 Free Software Foundation; either version 2, or (at your option) any
15 later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License along
23 with this program; if not, write to the Free Software Foundation, Inc.,
24 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 */
26 \f
27 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
28    Ditto for AIX 3.2 and <stdlib.h>.  */
29 #ifndef _NO_PROTO
30 #define _NO_PROTO
31 #endif
32
33 #ifdef HAVE_CONFIG_H
34 #include "../config.h"
35 #endif
36
37 #if !defined (__STDC__) || !__STDC__
38 /* This is a separate conditional since some stdc systems
39    reject `defined (const)'.  */
40 #ifndef const
41 #define const
42 #endif
43 #endif
44
45 #include <stdio.h>
46
47 #ifdef HAVE_STRING_H
48 #include <string.h>
49 #endif
50
51 /* Comment out all this code if we are using the GNU C Library, and are not
52    actually compiling the library itself.  This code is part of the GNU C
53    Library, but also included in many other GNU distributions.  Compiling
54    and linking in this code is a waste when using the GNU C library
55    (especially if it is a shared library).  Rather than having every GNU
56    program understand `configure --with-gnu-libc' and omit the object files,
57    it is simpler to just do this in the source for each such file.  */
58
59 #define GETOPT_INTERFACE_VERSION 2
60 #if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
61 #include <gnu-versions.h>
62 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
63 #define ELIDE_CODE
64 #endif
65 #endif
66
67 #ifndef ELIDE_CODE
68
69
70 /* This needs to come after some library #include
71    to get __GNU_LIBRARY__ defined.  */
72 #ifdef  __GNU_LIBRARY__
73 /* Don't include stdlib.h for non-GNU C libraries because some of them
74    contain conflicting prototypes for getopt.  */
75 #include <stdlib.h>
76 #include <unistd.h>
77 #endif  /* GNU C library.  */
78
79 #ifdef VMS
80 #include <unixlib.h>
81 #if HAVE_STRING_H - 0
82 #include <string.h>
83 #endif
84 #endif
85
86 #if defined (WIN32) && !defined (__CYGWIN32__)
87 /* It's not Unix, really.  See?  Capital letters.  */
88 #include <windows.h>
89 #define getpid() GetCurrentProcessId()
90 #endif
91
92 /* This version of `getopt' appears to the caller like standard Unix `getopt'
93    but it behaves differently for the user, since it allows the user
94    to intersperse the options with the other arguments.
95
96    As `getopt' works, it permutes the elements of ARGV so that,
97    when it is done, all the options precede everything else.  Thus
98    all application programs are extended to handle flexible argument order.
99
100    Setting the environment variable POSIXLY_CORRECT disables permutation.
101    Then the behavior is completely standard.
102
103    GNU application programs can use a third alternative mode in which
104    they can distinguish the relative order of options and other arguments.  */
105
106 #include "getopt.h"
107
108 /* For communication from `getopt' to the caller.
109    When `getopt' finds an option that takes an argument,
110    the argument value is returned here.
111    Also, when `ordering' is RETURN_IN_ORDER,
112    each non-option ARGV-element is returned here.  */
113
114 char *optarg = NULL;
115
116 /* Index in ARGV of the next element to be scanned.
117    This is used for communication to and from the caller
118    and for communication between successive calls to `getopt'.
119
120    On entry to `getopt', zero means this is the first call; initialize.
121
122    When `getopt' returns -1, this is the index of the first of the
123    non-option elements that the caller should itself scan.
124
125    Otherwise, `optind' communicates from one call to the next
126    how much of ARGV has been scanned so far.  */
127
128 /* 1003.2 says this must be 1 before any call.  */
129 int optind = 1;
130
131 /* Formerly, initialization of getopt depended on optind==0, which
132    causes problems with re-calling getopt as programs generally don't
133    know that. */
134
135 int __getopt_initialized = 0;
136
137 /* The next char to be scanned in the option-element
138    in which the last option character we returned was found.
139    This allows us to pick up the scan where we left off.
140
141    If this is zero, or a null string, it means resume the scan
142    by advancing to the next ARGV-element.  */
143
144 static char *nextchar;
145
146 /* Callers store zero here to inhibit the error message
147    for unrecognized options.  */
148
149 int opterr = 1;
150
151 /* Set to an option character which was unrecognized.
152    This must be initialized on some systems to avoid linking in the
153    system's own getopt implementation.  */
154
155 int optopt = '?';
156
157 /* Describe how to deal with options that follow non-option ARGV-elements.
158
159    If the caller did not specify anything,
160    the default is REQUIRE_ORDER if the environment variable
161    POSIXLY_CORRECT is defined, PERMUTE otherwise.
162
163    REQUIRE_ORDER means don't recognize them as options;
164    stop option processing when the first non-option is seen.
165    This is what Unix does.
166    This mode of operation is selected by either setting the environment
167    variable POSIXLY_CORRECT, or using `+' as the first character
168    of the list of option characters.
169
170    PERMUTE is the default.  We permute the contents of ARGV as we scan,
171    so that eventually all the non-options are at the end.  This allows options
172    to be given in any order, even with programs that were not written to
173    expect this.
174
175    RETURN_IN_ORDER is an option available to programs that were written
176    to expect options and other ARGV-elements in any order and that care about
177    the ordering of the two.  We describe each non-option ARGV-element
178    as if it were the argument of an option with character code 1.
179    Using `-' as the first character of the list of option characters
180    selects this mode of operation.
181
182    The special argument `--' forces an end of option-scanning regardless
183    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
184    `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
185
186 static enum {
187         REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
188 } ordering;
189
190 /* Value of POSIXLY_CORRECT environment variable.  */
191 static char *posixly_correct;
192 \f
193 #ifdef  __GNU_LIBRARY__
194 /* We want to avoid inclusion of string.h with non-GNU libraries
195    because there are many ways it can cause trouble.
196    On some systems, it contains special magic macros that don't work
197    in GCC.  */
198 #include <string.h>
199 #define my_index        strchr
200 #else
201
202 /* Avoid depending on library functions or files
203    whose names are inconsistent.  */
204
205 char *getenv();
206
207 static char *
208 my_index(str, chr)
209 const char *str;
210 int chr;
211 {
212         while(*str) {
213                 if(*str == chr) {
214                         return (char *) str;
215                 }
216
217                 str++;
218         }
219
220         return 0;
221 }
222
223 /* If using GCC, we can safely declare strlen this way.
224    If not using GCC, it is ok not to declare it.  */
225 #ifdef __GNUC__
226 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
227    That was relevant to code that was here before.  */
228 #if !defined (__STDC__) || !__STDC__
229 /* gcc with -traditional declares the built-in strlen to return int,
230    and has done so at least since version 2.4.5. -- rms.  */
231 extern int strlen(const char *);
232 #endif /* not __STDC__ */
233 #endif /* __GNUC__ */
234
235 #endif /* not __GNU_LIBRARY__ */
236 \f
237 /* Handle permutation of arguments.  */
238
239 /* Describe the part of ARGV that contains non-options that have
240    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
241    `last_nonopt' is the index after the last of them.  */
242
243 static int first_nonopt;
244 static int last_nonopt;
245
246 #ifdef _LIBC
247 /* Bash 2.0 gives us an environment variable containing flags
248    indicating ARGV elements that should not be considered arguments.  */
249
250 /* Defined in getopt_init.c  */
251 extern char *__getopt_nonoption_flags;
252
253 static int nonoption_flags_max_len;
254 static int nonoption_flags_len;
255
256 static int original_argc;
257 static char *const *original_argv;
258
259 extern pid_t __libc_pid;
260
261 /* Make sure the environment variable bash 2.0 puts in the environment
262    is valid for the getopt call we must make sure that the ARGV passed
263    to getopt is that one passed to the process.  */
264 static void
265 __attribute__((__unused__))
266 store_args_and_env(int argc, char *const *argv) {
267         /* XXX This is no good solution.  We should rather copy the args so
268            that we can compare them later.  But we must not use malloc(3).  */
269         original_argc = argc;
270         original_argv = argv;
271 }
272 text_set_element(__libc_subinit, store_args_and_env);
273
274 # define SWAP_FLAGS(ch1, ch2) \
275         if (nonoption_flags_len > 0)                                                \
276         {                                                                         \
277                 char __tmp = __getopt_nonoption_flags[ch1];                             \
278                 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
279                 __getopt_nonoption_flags[ch2] = __tmp;                                  \
280         }
281 #else   /* !_LIBC */
282 # define SWAP_FLAGS(ch1, ch2)
283 #endif  /* _LIBC */
284
285 /* Exchange two adjacent subsequences of ARGV.
286    One subsequence is elements [first_nonopt,last_nonopt)
287    which contains all the non-options that have been skipped so far.
288    The other is elements [last_nonopt,optind), which contains all
289    the options processed since those non-options were skipped.
290
291    `first_nonopt' and `last_nonopt' are relocated so that they describe
292    the new indices of the non-options in ARGV after they are moved.  */
293
294 #if defined (__STDC__) && __STDC__
295 static void exchange(char **);
296 #endif
297
298 static void
299 exchange(argv)
300 char **argv;
301 {
302         int bottom = first_nonopt;
303         int middle = last_nonopt;
304         int top = optind;
305         char *tem;
306
307         /* Exchange the shorter segment with the far end of the longer segment.
308            That puts the shorter segment into the right place.
309            It leaves the longer segment in the right place overall,
310            but it consists of two parts that need to be swapped next.  */
311
312 #ifdef _LIBC
313
314         /* First make sure the handling of the `__getopt_nonoption_flags'
315            string can work normally.  Our top argument must be in the range
316            of the string.  */
317         if(nonoption_flags_len > 0 && top >= nonoption_flags_max_len) {
318                 /* We must extend the array.  The user plays games with us and
319                  presents new arguments.  */
320                 char *new_str = malloc(top + 1);
321
322                 if(new_str == NULL) {
323                         nonoption_flags_len = nonoption_flags_max_len = 0;
324                 } else {
325                         memcpy(new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
326                         memset(&new_str[nonoption_flags_max_len], '\0',
327                                top + 1 - nonoption_flags_max_len);
328                         nonoption_flags_max_len = top + 1;
329                         __getopt_nonoption_flags = new_str;
330                 }
331         }
332
333 #endif
334
335         while(top > middle && middle > bottom) {
336                 if(top - middle > middle - bottom) {
337                         /* Bottom segment is the short one.  */
338                         int len = middle - bottom;
339                         register int i;
340
341                         /* Swap it with the top part of the top segment.  */
342                         for(i = 0; i < len; i++) {
343                                 tem = argv[bottom + i];
344                                 argv[bottom + i] = argv[top - (middle - bottom) + i];
345                                 argv[top - (middle - bottom) + i] = tem;
346                                 SWAP_FLAGS(bottom + i, top - (middle - bottom) + i);
347                         }
348
349                         /* Exclude the moved bottom segment from further swapping.  */
350                         top -= len;
351                 } else {
352                         /* Top segment is the short one.  */
353                         int len = top - middle;
354                         register int i;
355
356                         /* Swap it with the bottom part of the bottom segment.  */
357                         for(i = 0; i < len; i++) {
358                                 tem = argv[bottom + i];
359                                 argv[bottom + i] = argv[middle + i];
360                                 argv[middle + i] = tem;
361                                 SWAP_FLAGS(bottom + i, middle + i);
362                         }
363
364                         /* Exclude the moved top segment from further swapping.  */
365                         bottom += len;
366                 }
367         }
368
369         /* Update records for the slots the non-options now occupy.  */
370
371         first_nonopt += (optind - last_nonopt);
372         last_nonopt = optind;
373 }
374
375 /* Initialize the internal data when the first call is made.  */
376
377 #if defined (__STDC__) && __STDC__
378 static const char *_getopt_initialize(int, char *const *, const char *);
379 #endif
380 static const char *
381 _getopt_initialize(argc, argv, optstring)
382 int argc;
383 char *const *argv;
384 const char *optstring;
385 {
386         /* Start processing options with ARGV-element 1 (since ARGV-element 0
387            is the program name); the sequence of previously skipped
388            non-option ARGV-elements is empty.  */
389
390         first_nonopt = last_nonopt = optind;
391
392         nextchar = NULL;
393
394         posixly_correct = getenv("POSIXLY_CORRECT");
395
396         /* Determine how to handle the ordering of options and nonoptions.  */
397
398         if(optstring[0] == '-') {
399                 ordering = RETURN_IN_ORDER;
400                 ++optstring;
401         } else if(optstring[0] == '+') {
402                 ordering = REQUIRE_ORDER;
403                 ++optstring;
404         } else if(posixly_correct != NULL) {
405                 ordering = REQUIRE_ORDER;
406         } else {
407                 ordering = PERMUTE;
408         }
409
410 #ifdef _LIBC
411
412         if(posixly_correct == NULL
413                         && argc == original_argc && argv == original_argv) {
414                 if(nonoption_flags_max_len == 0) {
415                         if(__getopt_nonoption_flags == NULL
416                                         || __getopt_nonoption_flags[0] == '\0') {
417                                 nonoption_flags_max_len = -1;
418                         } else {
419                                 const char *orig_str = __getopt_nonoption_flags;
420                                 int len = nonoption_flags_max_len = strlen(orig_str);
421
422                                 if(nonoption_flags_max_len < argc) {
423                                         nonoption_flags_max_len = argc;
424                                 }
425
426                                 __getopt_nonoption_flags =
427                                         (char *) malloc(nonoption_flags_max_len);
428
429                                 if(__getopt_nonoption_flags == NULL) {
430                                         nonoption_flags_max_len = -1;
431                                 } else {
432                                         memcpy(__getopt_nonoption_flags, orig_str, len);
433                                         memset(&__getopt_nonoption_flags[len], '\0',
434                                                nonoption_flags_max_len - len);
435                                 }
436                         }
437                 }
438
439                 nonoption_flags_len = nonoption_flags_max_len;
440         } else {
441                 nonoption_flags_len = 0;
442         }
443
444 #endif
445
446         return optstring;
447 }
448 \f
449 /* Scan elements of ARGV (whose length is ARGC) for option characters
450    given in OPTSTRING.
451
452    If an element of ARGV starts with '-', and is not exactly "-" or "--",
453    then it is an option element.  The characters of this element
454    (aside from the initial '-') are option characters.  If `getopt'
455    is called repeatedly, it returns successively each of the option characters
456    from each of the option elements.
457
458    If `getopt' finds another option character, it returns that character,
459    updating `optind' and `nextchar' so that the next call to `getopt' can
460    resume the scan with the following option character or ARGV-element.
461
462    If there are no more option characters, `getopt' returns -1.
463    Then `optind' is the index in ARGV of the first ARGV-element
464    that is not an option.  (The ARGV-elements have been permuted
465    so that those that are not options now come last.)
466
467    OPTSTRING is a string containing the legitimate option characters.
468    If an option character is seen that is not listed in OPTSTRING,
469    return '?' after printing an error message.  If you set `opterr' to
470    zero, the error message is suppressed but we still return '?'.
471
472    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
473    so the following text in the same ARGV-element, or the text of the following
474    ARGV-element, is returned in `optarg'.  Two colons mean an option that
475    wants an optional arg; if there is text in the current ARGV-element,
476    it is returned in `optarg', otherwise `optarg' is set to zero.
477
478    If OPTSTRING starts with `-' or `+', it requests different methods of
479    handling the non-option ARGV-elements.
480    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
481
482    Long-named options begin with `--' instead of `-'.
483    Their names may be abbreviated as long as the abbreviation is unique
484    or is an exact match for some defined option.  If they have an
485    argument, it follows the option name in the same ARGV-element, separated
486    from the option name by a `=', or else the in next ARGV-element.
487    When `getopt' finds a long-named option, it returns 0 if that option's
488    `flag' field is nonzero, the value of the option's `val' field
489    if the `flag' field is zero.
490
491    The elements of ARGV aren't really const, because we permute them.
492    But we pretend they're const in the prototype to be compatible
493    with other systems.
494
495    LONGOPTS is a vector of `struct option' terminated by an
496    element containing a name which is zero.
497
498    LONGIND returns the index in LONGOPT of the long-named option found.
499    It is only valid when a long-named option has been found by the most
500    recent call.
501
502    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
503    long-named options.  */
504
505 int
506 _getopt_internal(argc, argv, optstring, longopts, longind, long_only)
507 int argc;
508 char *const *argv;
509 const char *optstring;
510 const struct option *longopts;
511 int *longind;
512 int long_only;
513 {
514         optarg = NULL;
515
516         if(optind == 0 || !__getopt_initialized) {
517                 if(optind == 0) {
518                         optind = 1;        /* Don't scan ARGV[0], the program name.  */
519                 }
520
521                 optstring = _getopt_initialize(argc, argv, optstring);
522                 __getopt_initialized = 1;
523         }
524
525         /* Test whether ARGV[optind] points to a non-option argument.
526            Either it does not have option syntax, or there is an environment flag
527            from the shell indicating it is not an option.  The later information
528            is only used when the used in the GNU libc.  */
529 #ifdef _LIBC
530 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
531                      || (optind < nonoption_flags_len                         \
532                          && __getopt_nonoption_flags[optind] == '1'))
533 #else
534 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
535 #endif
536
537         if(nextchar == NULL || *nextchar == '\0') {
538                 /* Advance to the next ARGV-element.  */
539
540                 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
541                  moved back by the user (who may also have changed the arguments).  */
542                 if(last_nonopt > optind) {
543                         last_nonopt = optind;
544                 }
545
546                 if(first_nonopt > optind) {
547                         first_nonopt = optind;
548                 }
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 && last_nonopt != optind) {
555                                 exchange((char **) argv);
556                         } else if(last_nonopt != optind) {
557                                 first_nonopt = optind;
558                         }
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                         }
566
567                         last_nonopt = optind;
568                 }
569
570                 /* The special ARGV-element `--' means premature end of options.
571                  Skip it like a null option,
572                  then exchange with previous non-options as if it were an option,
573                  then skip everything else like a non-option.  */
574
575                 if(optind != argc && !strcmp(argv[optind], "--")) {
576                         optind++;
577
578                         if(first_nonopt != last_nonopt && last_nonopt != optind) {
579                                 exchange((char **) argv);
580                         } else if(first_nonopt == last_nonopt) {
581                                 first_nonopt = optind;
582                         }
583
584                         last_nonopt = argc;
585
586                         optind = argc;
587                 }
588
589                 /* If we have done all the ARGV-elements, stop the scan
590                  and back over any non-options that we skipped and permuted.  */
591
592                 if(optind == argc) {
593                         /* Set the next-arg-index to point at the non-options
594                            that we previously skipped, so the caller will digest them.  */
595                         if(first_nonopt != last_nonopt) {
596                                 optind = first_nonopt;
597                         }
598
599                         return -1;
600                 }
601
602                 /* If we have come to a non-option and did not permute it,
603                  either stop the scan or describe it to the caller and pass it by.  */
604
605                 if(NONOPTION_P) {
606                         if(ordering == REQUIRE_ORDER) {
607                                 return -1;
608                         }
609
610                         optarg = argv[optind++];
611                         return 1;
612                 }
613
614                 /* We have found another option-ARGV-element.
615                  Skip the initial punctuation.  */
616
617                 nextchar = (argv[optind] + 1
618                             + (longopts != NULL && argv[optind][1] == '-'));
619         }
620
621         /* Decode the current option-ARGV-element.  */
622
623         /* Check whether the ARGV-element is a long option.
624
625            If long_only and the ARGV-element has the form "-f", where f is
626            a valid short option, don't consider it an abbreviated form of
627            a long option that starts with f.  Otherwise there would be no
628            way to give the -f short option.
629
630            On the other hand, if there's a long option "fubar" and
631            the ARGV-element is "-fu", do consider that an abbreviation of
632            the long option, just like "--fu", and not "-f" with arg "u".
633
634            This distinction seems to be the most useful approach.  */
635
636         if(longopts != NULL
637                         && (argv[optind][1] == '-'
638                             || (long_only && (argv[optind][2] || !my_index(optstring, argv[optind][1]))))) {
639                 char *nameend;
640                 const struct option *p;
641                 const struct option *pfound = NULL;
642                 int exact = 0;
643                 int ambig = 0;
644                 int indfound = -1;
645                 int option_index;
646
647                 for(nameend = nextchar; *nameend && *nameend != '='; nameend++)
648                         /* Do nothing.  */ ;
649
650                 /* Test all long options for either exact match
651                  or abbreviated matches.  */
652                 for(p = longopts, option_index = 0; p->name; p++, option_index++)
653                         if(!strncmp(p->name, nextchar, nameend - nextchar)) {
654                                 if((unsigned int)(nameend - nextchar)
655                                                 == (unsigned int) strlen(p->name)) {
656                                         /* Exact match found.  */
657                                         pfound = p;
658                                         indfound = option_index;
659                                         exact = 1;
660                                         break;
661                                 } else if(pfound == NULL) {
662                                         /* First nonexact match found.  */
663                                         pfound = p;
664                                         indfound = option_index;
665                                 } else
666                                         /* Second or later nonexact match found.  */
667                                 {
668                                         ambig = 1;
669                                 }
670                         }
671
672                 if(ambig && !exact) {
673                         if(opterr)
674                                 fprintf(stderr, "%s: option `%s' is ambiguous\n",
675                                         argv[0], argv[optind]);
676
677                         nextchar += strlen(nextchar);
678                         optind++;
679                         optopt = 0;
680                         return '?';
681                 }
682
683                 if(pfound != NULL) {
684                         option_index = indfound;
685                         optind++;
686
687                         if(*nameend) {
688                                 /* Don't test has_arg with >, because some C compilers don't
689                                  allow it to be used on enums.  */
690                                 if(pfound->has_arg) {
691                                         optarg = nameend + 1;
692                                 } else {
693                                         if(opterr) {
694                                                 if(argv[optind - 1][1] == '-')
695                                                         /* --option */
696                                                         fprintf(stderr,
697                                                                 "%s: option `--%s' doesn't allow an argument\n",
698                                                                 argv[0], pfound->name);
699                                                 else
700                                                         /* +option or -option */
701                                                         fprintf(stderr,
702                                                                 "%s: option `%c%s' doesn't allow an argument\n",
703                                                                 argv[0], argv[optind - 1][0], pfound->name);
704                                         }
705
706                                         nextchar += strlen(nextchar);
707
708                                         optopt = pfound->val;
709                                         return '?';
710                                 }
711                         } else if(pfound->has_arg == 1) {
712                                 if(optind < argc) {
713                                         optarg = argv[optind++];
714                                 } else {
715                                         if(opterr)
716                                                 fprintf(stderr,
717                                                         "%s: option `%s' requires an argument\n",
718                                                         argv[0], argv[optind - 1]);
719
720                                         nextchar += strlen(nextchar);
721                                         optopt = pfound->val;
722                                         return optstring[0] == ':' ? ':' : '?';
723                                 }
724                         }
725
726                         nextchar += strlen(nextchar);
727
728                         if(longind != NULL) {
729                                 *longind = option_index;
730                         }
731
732                         if(pfound->flag) {
733                                 *(pfound->flag) = pfound->val;
734                                 return 0;
735                         }
736
737                         return pfound->val;
738                 }
739
740                 /* Can't find it as a long option.  If this is not getopt_long_only,
741                  or the option starts with '--' or is not a valid short
742                  option, then it's an error.
743                  Otherwise interpret it as a short option.  */
744                 if(!long_only || argv[optind][1] == '-'
745                                 || my_index(optstring, *nextchar) == NULL) {
746                         if(opterr) {
747                                 if(argv[optind][1] == '-')
748                                         /* --option */
749                                         fprintf(stderr, "%s: unrecognized option `--%s'\n",
750                                                 argv[0], nextchar);
751                                 else
752                                         /* +option or -option */
753                                         fprintf(stderr, "%s: unrecognized option `%c%s'\n",
754                                                 argv[0], argv[optind][0], nextchar);
755                         }
756
757                         nextchar = (char *) "";
758                         optind++;
759                         optopt = 0;
760                         return '?';
761                 }
762         }
763
764         /* Look at and handle the next short option-character.  */
765
766         {
767                 char c = *nextchar++;
768                 char *temp = my_index(optstring, c);
769
770                 /* Increment `optind' when we start to process its last character.  */
771                 if(*nextchar == '\0') {
772                         ++optind;
773                 }
774
775                 if(temp == NULL || c == ':') {
776                         if(opterr) {
777                                 if(posixly_correct)
778                                         /* 1003.2 specifies the format of this message.  */
779                                         fprintf(stderr, "%s: illegal option -- %c\n",
780                                                 argv[0], c);
781                                 else
782                                         fprintf(stderr, "%s: invalid option -- %c\n",
783                                                 argv[0], c);
784                         }
785
786                         optopt = c;
787                         return '?';
788                 }
789
790                 /* Convenience. Treat POSIX -W foo same as long option --foo */
791                 if(temp[0] == 'W' && temp[1] == ';') {
792                         char *nameend;
793                         const struct option *p;
794                         const struct option *pfound = NULL;
795                         int exact = 0;
796                         int ambig = 0;
797                         int indfound = 0;
798                         int option_index;
799
800                         /* This is an option that requires an argument.  */
801                         if(*nextchar != '\0') {
802                                 optarg = nextchar;
803                                 /* If we end this ARGV-element by taking the rest as an arg,
804                                    we must advance to the next element now.  */
805                                 optind++;
806                         } else if(optind == argc) {
807                                 if(opterr) {
808                                         /* 1003.2 specifies the format of this message.  */
809                                         fprintf(stderr, "%s: option requires an argument -- %c\n",
810                                                 argv[0], c);
811                                 }
812
813                                 optopt = c;
814
815                                 if(optstring[0] == ':') {
816                                         c = ':';
817                                 } else {
818                                         c = '?';
819                                 }
820
821                                 return c;
822                         } else
823                                 /* We already incremented `optind' once;
824                                    increment it again when taking next ARGV-elt as argument.  */
825                         {
826                                 optarg = argv[optind++];
827                         }
828
829                         /* optarg is now the argument, see if it's in the
830                            table of longopts.  */
831
832                         for(nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
833                                 /* Do nothing.  */ ;
834
835                         /* Test all long options for either exact match
836                            or abbreviated matches.  */
837                         for(p = longopts, option_index = 0; p->name; p++, option_index++)
838                                 if(!strncmp(p->name, nextchar, nameend - nextchar)) {
839                                         if((unsigned int)(nameend - nextchar) == strlen(p->name)) {
840                                                 /* Exact match found.  */
841                                                 pfound = p;
842                                                 indfound = option_index;
843                                                 exact = 1;
844                                                 break;
845                                         } else if(pfound == NULL) {
846                                                 /* First nonexact match found.  */
847                                                 pfound = p;
848                                                 indfound = option_index;
849                                         } else
850                                                 /* Second or later nonexact match found.  */
851                                         {
852                                                 ambig = 1;
853                                         }
854                                 }
855
856                         if(ambig && !exact) {
857                                 if(opterr)
858                                         fprintf(stderr, "%s: option `-W %s' is ambiguous\n",
859                                                 argv[0], argv[optind]);
860
861                                 nextchar += strlen(nextchar);
862                                 optind++;
863                                 return '?';
864                         }
865
866                         if(pfound != NULL) {
867                                 option_index = indfound;
868
869                                 if(*nameend) {
870                                         /* Don't test has_arg with >, because some C compilers don't
871                                            allow it to be used on enums.  */
872                                         if(pfound->has_arg) {
873                                                 optarg = nameend + 1;
874                                         } else {
875                                                 if(opterr)
876                                                         fprintf(stderr,
877                                                                 "%s: option `-W %s' doesn't allow an argument\n",
878                                                                 argv[0], pfound->name);
879
880                                                 nextchar += strlen(nextchar);
881                                                 return '?';
882                                         }
883                                 } else if(pfound->has_arg == 1) {
884                                         if(optind < argc) {
885                                                 optarg = argv[optind++];
886                                         } else {
887                                                 if(opterr)
888                                                         fprintf(stderr,
889                                                                 "%s: option `%s' requires an argument\n",
890                                                                 argv[0], argv[optind - 1]);
891
892                                                 nextchar += strlen(nextchar);
893                                                 return optstring[0] == ':' ? ':' : '?';
894                                         }
895                                 }
896
897                                 nextchar += strlen(nextchar);
898
899                                 if(longind != NULL) {
900                                         *longind = option_index;
901                                 }
902
903                                 if(pfound->flag) {
904                                         *(pfound->flag) = pfound->val;
905                                         return 0;
906                                 }
907
908                                 return pfound->val;
909                         }
910
911                         nextchar = NULL;
912                         return 'W';   /* Let the application handle it.   */
913                 }
914
915                 if(temp[1] == ':') {
916                         if(temp[2] == ':') {
917                                 /* This is an option that accepts an argument optionally.  */
918                                 if(*nextchar != '\0') {
919                                         optarg = nextchar;
920                                         optind++;
921                                 } else {
922                                         optarg = NULL;
923                                 }
924
925                                 nextchar = NULL;
926                         } else {
927                                 /* This is an option that requires an argument.  */
928                                 if(*nextchar != '\0') {
929                                         optarg = nextchar;
930                                         /* If we end this ARGV-element by taking the rest as an arg,
931                                            we must advance to the next element now.  */
932                                         optind++;
933                                 } else if(optind == argc) {
934                                         if(opterr) {
935                                                 /* 1003.2 specifies the format of this message.  */
936                                                 fprintf(stderr,
937                                                         "%s: option requires an argument -- %c\n",
938                                                         argv[0], c);
939                                         }
940
941                                         optopt = c;
942
943                                         if(optstring[0] == ':') {
944                                                 c = ':';
945                                         } else {
946                                                 c = '?';
947                                         }
948                                 } else
949                                         /* We already incremented `optind' once;
950                                          increment it again when taking next ARGV-elt as argument.  */
951                                 {
952                                         optarg = argv[optind++];
953                                 }
954
955                                 nextchar = NULL;
956                         }
957                 }
958
959                 return c;
960         }
961 }
962
963 int
964 getopt(argc, argv, optstring)
965 int argc;
966 char *const *argv;
967 const char *optstring;
968 {
969         return _getopt_internal(argc, argv, optstring,
970                                 (const struct option *) 0,
971                                 (int *) 0,
972                                 0);
973 }
974
975 #endif  /* Not ELIDE_CODE.  */
976 \f
977 #ifdef TEST
978
979 /* Compile with -DTEST to make an executable for use in testing
980    the above definition of `getopt'.  */
981
982 int
983 main(argc, argv)
984 int argc;
985 char **argv;
986 {
987         int c;
988         int digit_optind = 0;
989
990         while(1) {
991                 int this_option_optind = optind ? optind : 1;
992
993                 c = getopt(argc, argv, "abc:d:0123456789");
994
995                 if(c == -1) {
996                         break;
997                 }
998
999                 switch(c) {
1000                 case '0':
1001                 case '1':
1002                 case '2':
1003                 case '3':
1004                 case '4':
1005                 case '5':
1006                 case '6':
1007                 case '7':
1008                 case '8':
1009                 case '9':
1010                         if(digit_optind != 0 && digit_optind != this_option_optind) {
1011                                 printf("digits occur in two different argv-elements.\n");
1012                         }
1013
1014                         digit_optind = this_option_optind;
1015                         printf("option %c\n", c);
1016                         break;
1017
1018                 case 'a':
1019                         printf("option a\n");
1020                         break;
1021
1022                 case 'b':
1023                         printf("option b\n");
1024                         break;
1025
1026                 case 'c':
1027                         printf("option c with value `%s'\n", optarg);
1028                         break;
1029
1030                 case '?':
1031                         break;
1032
1033                 default:
1034                         printf("?? getopt returned character code 0%o ??\n", c);
1035                 }
1036         }
1037
1038         if(optind < argc) {
1039                 printf("non-option ARGV-elements: ");
1040
1041                 while(optind < argc) {
1042                         printf("%s ", argv[optind++]);
1043                 }
1044
1045                 printf("\n");
1046         }
1047
1048         exit(0);
1049 }
1050
1051 #endif /* TEST */