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
7 Free Software Foundation, Inc.
8
9 This file is part of the libiberty library. This library is free
10 software; you can redistribute it and/or modify it under the
11 terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GNU CC; see the file COPYING. If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23
24 As a special exception, if you link this library with files
25 compiled with a GNU compiler to produce an executable, this does not cause
26 the resulting executable to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
29
30 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
31 Ditto for AIX 3.2 and <stdlib.h>. */
32 #ifndef _NO_PROTO
33 #define _NO_PROTO
34 #endif
35
36 #ifdef HAVE_CONFIG_H
37 #if defined (emacs) || defined (CONFIG_BROKETS)
38 /* We use <config.h> instead of "config.h" so that a compilation
39 using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
40 (which it would do because it found this file in $srcdir). */
41 #include <config.h>
42 #else
43 #include "config.h"
44 #endif
45 #endif
46
47 #ifndef __STDC__
48 /* This is a separate conditional since some stdc systems
49 reject `defined (const)'. */
50 #ifndef const
51 #define const
52 #endif
53 #endif
54
55 #include <stdio.h>
56
57 /* Comment out all this code if we are using the GNU C Library, and are not
58 actually compiling the library itself. This code is part of the GNU C
59 Library, but also included in many other GNU distributions. Compiling
60 and linking in this code is a waste when using the GNU C library
61 (especially if it is a shared library). Rather than having every GNU
62 program understand `configure --with-gnu-libc' and omit the object files,
63 it is simpler to just do this in the source for each such file. */
64 /* Many versions of the Linux C library include older, broken versions
65 of these routines, which will break the linker's command-line
66 parsing. */
67
68 #if defined (_LIBC) || !defined (__GNU_LIBRARY__) || defined (__linux__)
69
70
71 /* This needs to come after some library #include
72 to get __GNU_LIBRARY__ defined. */
73 #if defined(HAVE_STDLIB_H)
74 /* Don't include stdlib.h for non-GNU C libraries because some of them
75 contain conflicting prototypes for getopt. */
76 #include <stdlib.h>
77 #endif /* GNU C library. */
78
79 /* This version of `getopt' appears to the caller like standard Unix `getopt'
80 but it behaves differently for the user, since it allows the user
81 to intersperse the options with the other arguments.
82
83 As `getopt' works, it permutes the elements of ARGV so that,
84 when it is done, all the options precede everything else. Thus
85 all application programs are extended to handle flexible argument order.
86
87 Setting the environment variable POSIXLY_CORRECT disables permutation.
88 Then the behavior is completely standard.
89
90 GNU application programs can use a third alternative mode in which
91 they can distinguish the relative order of options and other arguments. */
92
93 #include "getopt.h"
94
95 /* For communication from `getopt' to the caller.
96 When `getopt' finds an option that takes an argument,
97 the argument value is returned here.
98 Also, when `ordering' is RETURN_IN_ORDER,
99 each non-option ARGV-element is returned here. */
100
101 char *optarg = NULL;
102
103 /* Index in ARGV of the next element to be scanned.
104 This is used for communication to and from the caller
105 and for communication between successive calls to `getopt'.
106
107 On entry to `getopt', zero means this is the first call; initialize.
108
109 When `getopt' returns EOF, this is the index of the first of the
110 non-option elements that the caller should itself scan.
111
112 Otherwise, `optind' communicates from one call to the next
113 how much of ARGV has been scanned so far. */
114
115 /* XXX 1003.2 says this must be 1 before any call. */
116 int optind = 0;
117
118 /* The next char to be scanned in the option-element
119 in which the last option character we returned was found.
120 This allows us to pick up the scan where we left off.
121
122 If this is zero, or a null string, it means resume the scan
123 by advancing to the next ARGV-element. */
124
125 static char *nextchar;
126
127 /* Callers store zero here to inhibit the error message
128 for unrecognized options. */
129
130 int opterr = 1;
131
132 /* Set to an option character which was unrecognized.
133 This must be initialized on some systems to avoid linking in the
134 system's own getopt implementation. */
135
136 int optopt = '?';
137
138 /* Describe how to deal with options that follow non-option ARGV-elements.
139
140 If the caller did not specify anything,
141 the default is REQUIRE_ORDER if the environment variable
142 POSIXLY_CORRECT is defined, PERMUTE otherwise.
143
144 REQUIRE_ORDER means don't recognize them as options;
145 stop option processing when the first non-option is seen.
146 This is what Unix does.
147 This mode of operation is selected by either setting the environment
148 variable POSIXLY_CORRECT, or using `+' as the first character
149 of the list of option characters.
150
151 PERMUTE is the default. We permute the contents of ARGV as we scan,
152 so that eventually all the non-options are at the end. This allows options
153 to be given in any order, even with programs that were not written to
154 expect this.
155
156 RETURN_IN_ORDER is an option available to programs that were written
157 to expect options and other ARGV-elements in any order and that care about
158 the ordering of the two. We describe each non-option ARGV-element
159 as if it were the argument of an option with character code 1.
160 Using `-' as the first character of the list of option characters
161 selects this mode of operation.
162
163 The special argument `--' forces an end of option-scanning regardless
164 of the value of `ordering'. In the case of RETURN_IN_ORDER, only
165 `--' can cause `getopt' to return EOF with `optind' != ARGC. */
166
167 static enum
168 {
169 REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
170 } ordering;
171
172 #if defined(HAVE_STRING_H)
173 /* We want to avoid inclusion of string.h with non-GNU libraries
174 because there are many ways it can cause trouble.
175 On some systems, it contains special magic macros that don't work
176 in GCC. */
177 #include <string.h>
178 #define my_index strchr
179 #else
180
181 /* Avoid depending on library functions or files
182 whose names are inconsistent. */
183
184 char *getenv ();
185
186 static char *
my_index(str,chr)187 my_index (str, chr)
188 const char *str;
189 int chr;
190 {
191 while (*str)
192 {
193 if (*str == chr)
194 return (char *) str;
195 str++;
196 }
197 return 0;
198 }
199
200 /* If using GCC, we can safely declare strlen this way.
201 If not using GCC, it is ok not to declare it. */
202 #ifdef __GNUC__
203 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
204 That was relevant to code that was here before. */
205 #ifndef __STDC__
206 /* gcc with -traditional declares the built-in strlen to return int,
207 and has done so at least since version 2.4.5. -- rms. */
208 extern int strlen (const char *);
209 #endif /* not __STDC__ */
210 #endif /* __GNUC__ */
211
212 #endif /* not __GNU_LIBRARY__ */
213
214 /* Handle permutation of arguments. */
215
216 /* Describe the part of ARGV that contains non-options that have
217 been skipped. `first_nonopt' is the index in ARGV of the first of them;
218 `last_nonopt' is the index after the last of them. */
219
220 static int first_nonopt;
221 static int last_nonopt;
222
223 /* Exchange two adjacent subsequences of ARGV.
224 One subsequence is elements [first_nonopt,last_nonopt)
225 which contains all the non-options that have been skipped so far.
226 The other is elements [last_nonopt,optind), which contains all
227 the options processed since those non-options were skipped.
228
229 `first_nonopt' and `last_nonopt' are relocated so that they describe
230 the new indices of the non-options in ARGV after they are moved. */
231
232 static void
exchange(char ** argv)233 exchange (char **argv)
234 {
235 int bottom = first_nonopt;
236 int middle = last_nonopt;
237 int top = optind;
238 char *tem;
239
240 /* Exchange the shorter segment with the far end of the longer segment.
241 That puts the shorter segment into the right place.
242 It leaves the longer segment in the right place overall,
243 but it consists of two parts that need to be swapped next. */
244
245 while (top > middle && middle > bottom)
246 {
247 if (top - middle > middle - bottom)
248 {
249 /* Bottom segment is the short one. */
250 int len = middle - bottom;
251 register int i;
252
253 /* Swap it with the top part of the top segment. */
254 for (i = 0; i < len; i++)
255 {
256 tem = argv[bottom + i];
257 argv[bottom + i] = argv[top - (middle - bottom) + i];
258 argv[top - (middle - bottom) + i] = tem;
259 }
260 /* Exclude the moved bottom segment from further swapping. */
261 top -= len;
262 }
263 else
264 {
265 /* Top segment is the short one. */
266 int len = top - middle;
267 register int i;
268
269 /* Swap it with the bottom part of the bottom segment. */
270 for (i = 0; i < len; i++)
271 {
272 tem = argv[bottom + i];
273 argv[bottom + i] = argv[middle + i];
274 argv[middle + i] = tem;
275 }
276 /* Exclude the moved top segment from further swapping. */
277 bottom += len;
278 }
279 }
280
281 /* Update records for the slots the non-options now occupy. */
282
283 first_nonopt += (optind - last_nonopt);
284 last_nonopt = optind;
285 }
286
287 /* Initialize the internal data when the first call is made. */
288
289 static const char *
_getopt_initialize(const char * optstring)290 _getopt_initialize (const char *optstring)
291 {
292 /* Start processing options with ARGV-element 1 (since ARGV-element 0
293 is the program name); the sequence of previously skipped
294 non-option ARGV-elements is empty. */
295
296 first_nonopt = last_nonopt = optind = 1;
297
298 nextchar = NULL;
299
300 /* Determine how to handle the ordering of options and nonoptions. */
301
302 if (optstring[0] == '-')
303 {
304 ordering = RETURN_IN_ORDER;
305 ++optstring;
306 }
307 else if (optstring[0] == '+')
308 {
309 ordering = REQUIRE_ORDER;
310 ++optstring;
311 }
312 else if (getenv ("POSIXLY_CORRECT") != NULL)
313 ordering = REQUIRE_ORDER;
314 else
315 ordering = PERMUTE;
316
317 return optstring;
318 }
319
320 /* Scan elements of ARGV (whose length is ARGC) for option characters
321 given in OPTSTRING.
322
323 If an element of ARGV starts with '-', and is not exactly "-" or "--",
324 then it is an option element. The characters of this element
325 (aside from the initial '-') are option characters. If `getopt'
326 is called repeatedly, it returns successively each of the option characters
327 from each of the option elements.
328
329 If `getopt' finds another option character, it returns that character,
330 updating `optind' and `nextchar' so that the next call to `getopt' can
331 resume the scan with the following option character or ARGV-element.
332
333 If there are no more option characters, `getopt' returns `EOF'.
334 Then `optind' is the index in ARGV of the first ARGV-element
335 that is not an option. (The ARGV-elements have been permuted
336 so that those that are not options now come last.)
337
338 OPTSTRING is a string containing the legitimate option characters.
339 If an option character is seen that is not listed in OPTSTRING,
340 return '?' after printing an error message. If you set `opterr' to
341 zero, the error message is suppressed but we still return '?'.
342
343 If a char in OPTSTRING is followed by a colon, that means it wants an arg,
344 so the following text in the same ARGV-element, or the text of the following
345 ARGV-element, is returned in `optarg'. Two colons mean an option that
346 wants an optional arg; if there is text in the current ARGV-element,
347 it is returned in `optarg', otherwise `optarg' is set to zero.
348
349 If OPTSTRING starts with `-' or `+', it requests different methods of
350 handling the non-option ARGV-elements.
351 See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
352
353 Long-named options begin with `--' instead of `-'.
354 Their names may be abbreviated as long as the abbreviation is unique
355 or is an exact match for some defined option. If they have an
356 argument, it follows the option name in the same ARGV-element, separated
357 from the option name by a `=', or else the in next ARGV-element.
358 When `getopt' finds a long-named option, it returns 0 if that option's
359 `flag' field is nonzero, the value of the option's `val' field
360 if the `flag' field is zero.
361
362 The elements of ARGV aren't really const, because we permute them.
363 But we pretend they're const in the prototype to be compatible
364 with other systems.
365
366 LONGOPTS is a vector of `struct option' terminated by an
367 element containing a name which is zero.
368
369 LONGIND returns the index in LONGOPT of the long-named option found.
370 It is only valid when a long-named option has been found by the most
371 recent call.
372
373 If LONG_ONLY is nonzero, '-' as well as '--' can introduce
374 long-named options. */
375
376 int
_getopt_internal(argc,argv,optstring,longopts,longind,long_only)377 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
378 int argc;
379 char *const *argv;
380 const char *optstring;
381 const struct option *longopts;
382 int *longind;
383 int long_only;
384 {
385 optarg = NULL;
386
387 if (optind == 0)
388 optstring = _getopt_initialize (optstring);
389
390 if (argc == 0)
391 return EOF;
392
393 if (nextchar == NULL || *nextchar == '\0')
394 {
395 /* Advance to the next ARGV-element. */
396
397 if (ordering == PERMUTE)
398 {
399 /* If we have just processed some options following some non-options,
400 exchange them so that the options come first. */
401
402 if (first_nonopt != last_nonopt && last_nonopt != optind)
403 exchange ((char **) argv);
404 else if (last_nonopt != optind)
405 first_nonopt = optind;
406
407 /* Skip any additional non-options
408 and extend the range of non-options previously skipped. */
409
410 while (optind < argc
411 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
412 optind++;
413 last_nonopt = optind;
414 }
415
416 /* The special ARGV-element `--' means premature end of options.
417 Skip it like a null option,
418 then exchange with previous non-options as if it were an option,
419 then skip everything else like a non-option. */
420
421 if (optind != argc && !strcmp (argv[optind], "--"))
422 {
423 optind++;
424
425 if (first_nonopt != last_nonopt && last_nonopt != optind)
426 exchange ((char **) argv);
427 else if (first_nonopt == last_nonopt)
428 first_nonopt = optind;
429 last_nonopt = argc;
430
431 optind = argc;
432 }
433
434 /* If we have done all the ARGV-elements, stop the scan
435 and back over any non-options that we skipped and permuted. */
436
437 if (optind == argc)
438 {
439 /* Set the next-arg-index to point at the non-options
440 that we previously skipped, so the caller will digest them. */
441 if (first_nonopt != last_nonopt)
442 optind = first_nonopt;
443 return EOF;
444 }
445
446 /* If we have come to a non-option and did not permute it,
447 either stop the scan or describe it to the caller and pass it by. */
448
449 if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
450 {
451 if (ordering == REQUIRE_ORDER)
452 return EOF;
453 optarg = argv[optind++];
454 return 1;
455 }
456
457 /* We have found another option-ARGV-element.
458 Skip the initial punctuation. */
459
460 nextchar = (argv[optind] + 1
461 + (longopts != NULL && argv[optind][1] == '-'));
462 }
463
464 /* Decode the current option-ARGV-element. */
465
466 /* Check whether the ARGV-element is a long option.
467
468 If long_only and the ARGV-element has the form "-f", where f is
469 a valid short option, don't consider it an abbreviated form of
470 a long option that starts with f. Otherwise there would be no
471 way to give the -f short option.
472
473 On the other hand, if there's a long option "fubar" and
474 the ARGV-element is "-fu", do consider that an abbreviation of
475 the long option, just like "--fu", and not "-f" with arg "u".
476
477 This distinction seems to be the most useful approach. */
478
479 if (longopts != NULL
480 && (argv[optind][1] == '-'
481 || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
482 {
483 char *nameend;
484 const struct option *p;
485 const struct option *pfound = NULL;
486 int exact = 0;
487 int ambig = 0;
488 int indfound;
489 int option_index;
490
491 for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
492 /* Do nothing. */ ;
493
494 /* Test all long options for either exact match
495 or abbreviated matches. */
496 for (p = longopts, option_index = 0; p->name; p++, option_index++)
497 if (!strncmp (p->name, nextchar, nameend - nextchar))
498 {
499 if (nameend - nextchar == strlen (p->name))
500 {
501 /* Exact match found. */
502 pfound = p;
503 indfound = option_index;
504 exact = 1;
505 break;
506 }
507 else if (pfound == NULL)
508 {
509 /* First nonexact match found. */
510 pfound = p;
511 indfound = option_index;
512 }
513 else
514 /* Second or later nonexact match found. */
515 ambig = 1;
516 }
517
518 if (ambig && !exact)
519 {
520 if (opterr)
521 fprintf (stderr, "%s: option `%s' is ambiguous\n",
522 argv[0], argv[optind]);
523 nextchar += strlen (nextchar);
524 optind++;
525 return '?';
526 }
527
528 if (pfound != NULL)
529 {
530 option_index = indfound;
531 optind++;
532 if (*nameend)
533 {
534 /* Don't test has_arg with >, because some C compilers don't
535 allow it to be used on enums. */
536 if (pfound->has_arg)
537 optarg = nameend + 1;
538 else
539 {
540 if (opterr)
541 {
542 if (argv[optind - 1][1] == '-')
543 /* --option */
544 fprintf (stderr,
545 "%s: option `--%s' doesn't allow an argument\n",
546 argv[0], pfound->name);
547 else
548 /* +option or -option */
549 fprintf (stderr,
550 "%s: option `%c%s' doesn't allow an argument\n",
551 argv[0], argv[optind - 1][0], pfound->name);
552 }
553 nextchar += strlen (nextchar);
554 return '?';
555 }
556 }
557 else if (pfound->has_arg == 1)
558 {
559 if (optind < argc)
560 optarg = argv[optind++];
561 else
562 {
563 if (opterr)
564 fprintf (stderr, "%s: option `%s' requires an argument\n",
565 argv[0], argv[optind - 1]);
566 nextchar += strlen (nextchar);
567 return optstring[0] == ':' ? ':' : '?';
568 }
569 }
570 nextchar += strlen (nextchar);
571 if (longind != NULL)
572 *longind = option_index;
573 if (pfound->flag)
574 {
575 *(pfound->flag) = pfound->val;
576 return 0;
577 }
578 return pfound->val;
579 }
580
581 /* Can't find it as a long option. If this is not getopt_long_only,
582 or the option starts with '--' or is not a valid short
583 option, then it's an error.
584 Otherwise interpret it as a short option. */
585 if (!long_only || argv[optind][1] == '-'
586 || my_index (optstring, *nextchar) == NULL)
587 {
588 if (opterr)
589 {
590 if (argv[optind][1] == '-')
591 /* --option */
592 fprintf (stderr, "%s: unrecognized option `--%s'\n",
593 argv[0], nextchar);
594 else
595 /* +option or -option */
596 fprintf (stderr, "%s: unrecognized option `%c%s'\n",
597 argv[0], argv[optind][0], nextchar);
598 }
599 nextchar = (char *) "";
600 optind++;
601 return '?';
602 }
603 }
604
605 /* Look at and handle the next short option-character. */
606
607 {
608 char c = *nextchar++;
609 char *temp = my_index (optstring, c);
610
611 /* Increment `optind' when we start to process its last character. */
612 if (*nextchar == '\0')
613 ++optind;
614
615 if (temp == NULL || c == ':')
616 {
617 if (opterr)
618 {
619 /* 1003.2 specifies the format of this message. */
620 fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
621 }
622 optopt = c;
623 return '?';
624 }
625 if (temp[1] == ':')
626 {
627 if (temp[2] == ':')
628 {
629 /* This is an option that accepts an argument optionally. */
630 if (*nextchar != '\0')
631 {
632 optarg = nextchar;
633 optind++;
634 }
635 else
636 optarg = NULL;
637 nextchar = NULL;
638 }
639 else
640 {
641 /* This is an option that requires an argument. */
642 if (*nextchar != '\0')
643 {
644 optarg = nextchar;
645 /* If we end this ARGV-element by taking the rest as an arg,
646 we must advance to the next element now. */
647 optind++;
648 }
649 else if (optind == argc)
650 {
651 if (opterr)
652 {
653 /* 1003.2 specifies the format of this message. */
654 fprintf (stderr, "%s: option requires an argument -- %c\n",
655 argv[0], c);
656 }
657 optopt = c;
658 if (optstring[0] == ':')
659 c = ':';
660 else
661 c = '?';
662 }
663 else
664 /* We already incremented `optind' once;
665 increment it again when taking next ARGV-elt as argument. */
666 optarg = argv[optind++];
667 nextchar = NULL;
668 }
669 }
670 return c;
671 }
672 }
673
674 #endif /* _LIBC or not __GNU_LIBRARY__. */
675
676 #ifdef TEST
677
678 /* Compile with -DTEST to make an executable for use in testing
679 the above definition of `getopt'. */
680
681 int
main(argc,argv)682 main (argc, argv)
683 int argc;
684 char **argv;
685 {
686 int c;
687 int digit_optind = 0;
688
689 while (1)
690 {
691 int this_option_optind = optind ? optind : 1;
692
693 c = getopt (argc, argv, "abc:d:0123456789");
694 if (c == EOF)
695 break;
696
697 switch (c)
698 {
699 case '0':
700 case '1':
701 case '2':
702 case '3':
703 case '4':
704 case '5':
705 case '6':
706 case '7':
707 case '8':
708 case '9':
709 if (digit_optind != 0 && digit_optind != this_option_optind)
710 printf ("digits occur in two different argv-elements.\n");
711 digit_optind = this_option_optind;
712 printf ("option %c\n", c);
713 break;
714
715 case 'a':
716 printf ("option a\n");
717 break;
718
719 case 'b':
720 printf ("option b\n");
721 break;
722
723 case 'c':
724 printf ("option c with value `%s'\n", optarg);
725 break;
726
727 case '?':
728 break;
729
730 default:
731 printf ("?? getopt returned character code 0%o ??\n", c);
732 }
733 }
734
735 if (optind < argc)
736 {
737 printf ("non-option ARGV-elements: ");
738 while (optind < argc)
739 printf ("%s ", argv[optind++]);
740 printf ("\n");
741 }
742
743 exit (0);
744 }
745
746 #endif /* TEST */
747