![[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.