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