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