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