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