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