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