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