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