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