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