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