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