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