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