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