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