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