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 (at) gnu.org 4 before changing it! 5 6 Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 7 1996, 1997, 1998, 2005 Free Software Foundation, Inc. 8 9 NOTE: This source is derived from an old version taken from the GNU C 10 Library (glibc). 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, 25 USA. */ 26 27 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. 29 Ditto for AIX 3.2 and <stdlib.h>. */ 30 #ifndef _NO_PROTO 31 # define _NO_PROTO 32 #endif 33 34 #ifdef HAVE_CONFIG_H 35 # include <config.h> 36 #endif 37 38 #if !defined __STDC__ || !__STDC__ 39 /* This is a separate conditional since some stdc systems 40 reject `defined (const)'. */ 41 # ifndef const 42 # define const 43 # endif 44 #endif 45 46 #include "ansidecl.h" 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 # if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC 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__ 199 /* We want to avoid inclusion of string.h with non-GNU libraries 200 because there are many ways it can cause trouble. 201 On some systems, it contains special magic macros that don't work 202 in GCC. */ 203 # include <string.h> 204 # define my_index strchr 205 #else 206 207 # if HAVE_STRING_H 208 # include <string.h> 209 # else 210 # if HAVE_STRINGS_H 211 # include <strings.h> 212 # endif 213 # endif 214 215 /* Avoid depending on library functions or files 216 whose names are inconsistent. */ 217 218 #if HAVE_STDLIB_H && HAVE_DECL_GETENV 219 # include <stdlib.h> 220 #elif !defined(getenv) 221 # ifdef __cplusplus 222 extern "C" { 223 # endif /* __cplusplus */ 224 extern char *getenv (const char *); 225 # ifdef __cplusplus 226 } 227 # endif /* __cplusplus */ 228 #endif 229 230 static char * 231 my_index (const char *str, int chr) 232 { 233 while (*str) 234 { 235 if (*str == chr) 236 return (char *) str; 237 str++; 238 } 239 return 0; 240 } 241 242 /* If using GCC, we can safely declare strlen this way. 243 If not using GCC, it is ok not to declare it. */ 244 #ifdef __GNUC__ 245 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. 246 That was relevant to code that was here before. */ 247 # if (!defined __STDC__ || !__STDC__) && !defined strlen 248 /* gcc with -traditional declares the built-in strlen to return int, 249 and has done so at least since version 2.4.5. -- rms. */ 250 extern int strlen (const char *); 251 # endif /* not __STDC__ */ 252 #endif /* __GNUC__ */ 253 254 #endif /* not __GNU_LIBRARY__ */ 255 256 /* Handle permutation of arguments. */ 258 259 /* Describe the part of ARGV that contains non-options that have 260 been skipped. `first_nonopt' is the index in ARGV of the first of them; 261 `last_nonopt' is the index after the last of them. */ 262 263 static int first_nonopt; 264 static int last_nonopt; 265 266 #ifdef _LIBC 267 /* Bash 2.0 gives us an environment variable containing flags 268 indicating ARGV elements that should not be considered arguments. */ 269 270 /* Defined in getopt_init.c */ 271 extern char *__getopt_nonoption_flags; 272 273 static int nonoption_flags_max_len; 274 static int nonoption_flags_len; 275 276 static int original_argc; 277 static char *const *original_argv; 278 279 /* Make sure the environment variable bash 2.0 puts in the environment 280 is valid for the getopt call we must make sure that the ARGV passed 281 to getopt is that one passed to the process. */ 282 static void 283 __attribute__ ((unused)) 284 store_args_and_env (int argc, char *const *argv) 285 { 286 /* XXX This is no good solution. We should rather copy the args so 287 that we can compare them later. But we must not use malloc(3). */ 288 original_argc = argc; 289 original_argv = argv; 290 } 291 # ifdef text_set_element 292 text_set_element (__libc_subinit, store_args_and_env); 293 # endif /* text_set_element */ 294 295 # define SWAP_FLAGS(ch1, ch2) \ 296 if (nonoption_flags_len > 0) \ 297 { \ 298 char __tmp = __getopt_nonoption_flags[ch1]; \ 299 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ 300 __getopt_nonoption_flags[ch2] = __tmp; \ 301 } 302 #else /* !_LIBC */ 303 # define SWAP_FLAGS(ch1, ch2) 304 #endif /* _LIBC */ 305 306 /* Exchange two adjacent subsequences of ARGV. 307 One subsequence is elements [first_nonopt,last_nonopt) 308 which contains all the non-options that have been skipped so far. 309 The other is elements [last_nonopt,optind), which contains all 310 the options processed since those non-options were skipped. 311 312 `first_nonopt' and `last_nonopt' are relocated so that they describe 313 the new indices of the non-options in ARGV after they are moved. */ 314 315 #if defined __STDC__ && __STDC__ 316 static void exchange (char **); 317 #endif 318 319 static void 320 exchange (char **argv) 321 { 322 int bottom = first_nonopt; 323 int middle = last_nonopt; 324 int top = optind; 325 char *tem; 326 327 /* Exchange the shorter segment with the far end of the longer segment. 328 That puts the shorter segment into the right place. 329 It leaves the longer segment in the right place overall, 330 but it consists of two parts that need to be swapped next. */ 331 332 #ifdef _LIBC 333 /* First make sure the handling of the `__getopt_nonoption_flags' 334 string can work normally. Our top argument must be in the range 335 of the string. */ 336 if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) 337 { 338 /* We must extend the array. The user plays games with us and 339 presents new arguments. */ 340 char *new_str = (char *) malloc (top + 1); 341 if (new_str == NULL) 342 nonoption_flags_len = nonoption_flags_max_len = 0; 343 else 344 { 345 memset (mempcpy (new_str, __getopt_nonoption_flags, 346 nonoption_flags_max_len), 347 '\0', top + 1 - nonoption_flags_max_len); 348 nonoption_flags_max_len = top + 1; 349 __getopt_nonoption_flags = new_str; 350 } 351 } 352 #endif 353 354 while (top > middle && middle > bottom) 355 { 356 if (top - middle > middle - bottom) 357 { 358 /* Bottom segment is the short one. */ 359 int len = middle - bottom; 360 register int i; 361 362 /* Swap it with the top part of the top segment. */ 363 for (i = 0; i < len; i++) 364 { 365 tem = argv[bottom + i]; 366 argv[bottom + i] = argv[top - (middle - bottom) + i]; 367 argv[top - (middle - bottom) + i] = tem; 368 SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); 369 } 370 /* Exclude the moved bottom segment from further swapping. */ 371 top -= len; 372 } 373 else 374 { 375 /* Top segment is the short one. */ 376 int len = top - middle; 377 register int i; 378 379 /* Swap it with the bottom part of the bottom segment. */ 380 for (i = 0; i < len; i++) 381 { 382 tem = argv[bottom + i]; 383 argv[bottom + i] = argv[middle + i]; 384 argv[middle + i] = tem; 385 SWAP_FLAGS (bottom + i, middle + i); 386 } 387 /* Exclude the moved top segment from further swapping. */ 388 bottom += len; 389 } 390 } 391 392 /* Update records for the slots the non-options now occupy. */ 393 394 first_nonopt += (optind - last_nonopt); 395 last_nonopt = optind; 396 } 397 398 /* Initialize the internal data when the first call is made. */ 399 400 #if defined __STDC__ && __STDC__ 401 static const char *_getopt_initialize (int, char *const *, const char *); 402 #endif 403 static const char * 404 _getopt_initialize (int argc ATTRIBUTE_UNUSED, 405 char *const *argv ATTRIBUTE_UNUSED, 406 const char *optstring) 407 { 408 /* Start processing options with ARGV-element 1 (since ARGV-element 0 409 is the program name); the sequence of previously skipped 410 non-option ARGV-elements is empty. */ 411 412 first_nonopt = last_nonopt = optind; 413 414 nextchar = NULL; 415 416 posixly_correct = getenv ("POSIXLY_CORRECT"); 417 418 /* Determine how to handle the ordering of options and nonoptions. */ 419 420 if (optstring[0] == '-') 421 { 422 ordering = RETURN_IN_ORDER; 423 ++optstring; 424 } 425 else if (optstring[0] == '+') 426 { 427 ordering = REQUIRE_ORDER; 428 ++optstring; 429 } 430 else if (posixly_correct != NULL) 431 ordering = REQUIRE_ORDER; 432 else 433 ordering = PERMUTE; 434 435 #ifdef _LIBC 436 if (posixly_correct == NULL 437 && argc == original_argc && argv == original_argv) 438 { 439 if (nonoption_flags_max_len == 0) 440 { 441 if (__getopt_nonoption_flags == NULL 442 || __getopt_nonoption_flags[0] == '\0') 443 nonoption_flags_max_len = -1; 444 else 445 { 446 const char *orig_str = __getopt_nonoption_flags; 447 int len = nonoption_flags_max_len = strlen (orig_str); 448 if (nonoption_flags_max_len < argc) 449 nonoption_flags_max_len = argc; 450 __getopt_nonoption_flags = 451 (char *) malloc (nonoption_flags_max_len); 452 if (__getopt_nonoption_flags == NULL) 453 nonoption_flags_max_len = -1; 454 else 455 memset (mempcpy (__getopt_nonoption_flags, orig_str, len), 456 '\0', nonoption_flags_max_len - len); 457 } 458 } 459 nonoption_flags_len = nonoption_flags_max_len; 460 } 461 else 462 nonoption_flags_len = 0; 463 #endif 464 465 return optstring; 466 } 467 468 /* Scan elements of ARGV (whose length is ARGC) for option characters 470 given in OPTSTRING. 471 472 If an element of ARGV starts with '-', and is not exactly "-" or "--", 473 then it is an option element. The characters of this element 474 (aside from the initial '-') are option characters. If `getopt' 475 is called repeatedly, it returns successively each of the option characters 476 from each of the option elements. 477 478 If `getopt' finds another option character, it returns that character, 479 updating `optind' and `nextchar' so that the next call to `getopt' can 480 resume the scan with the following option character or ARGV-element. 481 482 If there are no more option characters, `getopt' returns -1. 483 Then `optind' is the index in ARGV of the first ARGV-element 484 that is not an option. (The ARGV-elements have been permuted 485 so that those that are not options now come last.) 486 487 OPTSTRING is a string containing the legitimate option characters. 488 If an option character is seen that is not listed in OPTSTRING, 489 return '?' after printing an error message. If you set `opterr' to 490 zero, the error message is suppressed but we still return '?'. 491 492 If a char in OPTSTRING is followed by a colon, that means it wants an arg, 493 so the following text in the same ARGV-element, or the text of the following 494 ARGV-element, is returned in `optarg'. Two colons mean an option that 495 wants an optional arg; if there is text in the current ARGV-element, 496 it is returned in `optarg', otherwise `optarg' is set to zero. 497 498 If OPTSTRING starts with `-' or `+', it requests different methods of 499 handling the non-option ARGV-elements. 500 See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. 501 502 Long-named options begin with `--' instead of `-'. 503 Their names may be abbreviated as long as the abbreviation is unique 504 or is an exact match for some defined option. If they have an 505 argument, it follows the option name in the same ARGV-element, separated 506 from the option name by a `=', or else the in next ARGV-element. 507 When `getopt' finds a long-named option, it returns 0 if that option's 508 `flag' field is nonzero, the value of the option's `val' field 509 if the `flag' field is zero. 510 511 The elements of ARGV aren't really const, because we permute them. 512 But we pretend they're const in the prototype to be compatible 513 with other systems. 514 515 LONGOPTS is a vector of `struct option' terminated by an 516 element containing a name which is zero. 517 518 LONGIND returns the index in LONGOPT of the long-named option found. 519 It is only valid when a long-named option has been found by the most 520 recent call. 521 522 If LONG_ONLY is nonzero, '-' as well as '--' can introduce 523 long-named options. */ 524 525 int 526 _getopt_internal (int argc, char *const *argv, const char *optstring, 527 const struct option *longopts, 528 int *longind, int long_only) 529 { 530 optarg = NULL; 531 532 if (optind == 0 || !__getopt_initialized) 533 { 534 if (optind == 0) 535 optind = 1; /* Don't scan ARGV[0], the program name. */ 536 optstring = _getopt_initialize (argc, argv, optstring); 537 __getopt_initialized = 1; 538 } 539 540 /* Test whether ARGV[optind] points to a non-option argument. 541 Either it does not have option syntax, or there is an environment flag 542 from the shell indicating it is not an option. The later information 543 is only used when the used in the GNU libc. */ 544 #ifdef _LIBC 545 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ 546 || (optind < nonoption_flags_len \ 547 && __getopt_nonoption_flags[optind] == '1')) 548 #else 549 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') 550 #endif 551 552 if (nextchar == NULL || *nextchar == '\0') 553 { 554 /* Advance to the next ARGV-element. */ 555 556 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been 557 moved back by the user (who may also have changed the arguments). */ 558 if (last_nonopt > optind) 559 last_nonopt = optind; 560 if (first_nonopt > optind) 561 first_nonopt = optind; 562 563 if (ordering == PERMUTE) 564 { 565 /* If we have just processed some options following some non-options, 566 exchange them so that the options come first. */ 567 568 if (first_nonopt != last_nonopt && last_nonopt != optind) 569 exchange ((char **) argv); 570 else if (last_nonopt != optind) 571 first_nonopt = optind; 572 573 /* Skip any additional non-options 574 and extend the range of non-options previously skipped. */ 575 576 while (optind < argc && NONOPTION_P) 577 optind++; 578 last_nonopt = optind; 579 } 580 581 /* The special ARGV-element `--' means premature end of options. 582 Skip it like a null option, 583 then exchange with previous non-options as if it were an option, 584 then skip everything else like a non-option. */ 585 586 if (optind != argc && !strcmp (argv[optind], "--")) 587 { 588 optind++; 589 590 if (first_nonopt != last_nonopt && last_nonopt != optind) 591 exchange ((char **) argv); 592 else if (first_nonopt == last_nonopt) 593 first_nonopt = optind; 594 last_nonopt = argc; 595 596 optind = argc; 597 } 598 599 /* If we have done all the ARGV-elements, stop the scan 600 and back over any non-options that we skipped and permuted. */ 601 602 if (optind == argc) 603 { 604 /* Set the next-arg-index to point at the non-options 605 that we previously skipped, so the caller will digest them. */ 606 if (first_nonopt != last_nonopt) 607 optind = first_nonopt; 608 return -1; 609 } 610 611 /* If we have come to a non-option and did not permute it, 612 either stop the scan or describe it to the caller and pass it by. */ 613 614 if (NONOPTION_P) 615 { 616 if (ordering == REQUIRE_ORDER) 617 return -1; 618 optarg = argv[optind++]; 619 return 1; 620 } 621 622 /* We have found another option-ARGV-element. 623 Skip the initial punctuation. */ 624 625 nextchar = (argv[optind] + 1 626 + (longopts != NULL && argv[optind][1] == '-')); 627 } 628 629 /* Decode the current option-ARGV-element. */ 630 631 /* Check whether the ARGV-element is a long option. 632 633 If long_only and the ARGV-element has the form "-f", where f is 634 a valid short option, don't consider it an abbreviated form of 635 a long option that starts with f. Otherwise there would be no 636 way to give the -f short option. 637 638 On the other hand, if there's a long option "fubar" and 639 the ARGV-element is "-fu", do consider that an abbreviation of 640 the long option, just like "--fu", and not "-f" with arg "u". 641 642 This distinction seems to be the most useful approach. */ 643 644 if (longopts != NULL 645 && (argv[optind][1] == '-' 646 || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) 647 { 648 char *nameend; 649 const struct option *p; 650 const struct option *pfound = NULL; 651 int exact = 0; 652 int ambig = 0; 653 int indfound = -1; 654 int option_index; 655 656 for (nameend = nextchar; *nameend && *nameend != '='; nameend++) 657 /* Do nothing. */ ; 658 659 /* Test all long options for either exact match 660 or abbreviated matches. */ 661 for (p = longopts, option_index = 0; p->name; p++, option_index++) 662 if (!strncmp (p->name, nextchar, nameend - nextchar)) 663 { 664 if ((unsigned int) (nameend - nextchar) 665 == (unsigned int) strlen (p->name)) 666 { 667 /* Exact match found. */ 668 pfound = p; 669 indfound = option_index; 670 exact = 1; 671 break; 672 } 673 else if (pfound == NULL) 674 { 675 /* First nonexact match found. */ 676 pfound = p; 677 indfound = option_index; 678 } 679 else 680 /* Second or later nonexact match found. */ 681 ambig = 1; 682 } 683 684 if (ambig && !exact) 685 { 686 if (opterr) 687 fprintf (stderr, _("%s: option `%s' is ambiguous\n"), 688 argv[0], argv[optind]); 689 nextchar += strlen (nextchar); 690 optind++; 691 optopt = 0; 692 return '?'; 693 } 694 695 if (pfound != NULL) 696 { 697 option_index = indfound; 698 optind++; 699 if (*nameend) 700 { 701 /* Don't test has_arg with >, because some C compilers don't 702 allow it to be used on enums. */ 703 if (pfound->has_arg) 704 optarg = nameend + 1; 705 else 706 { 707 if (opterr) 708 { 709 if (argv[optind - 1][1] == '-') 710 /* --option */ 711 fprintf (stderr, 712 _("%s: option `--%s' doesn't allow an argument\n"), 713 argv[0], pfound->name); 714 else 715 /* +option or -option */ 716 fprintf (stderr, 717 _("%s: option `%c%s' doesn't allow an argument\n"), 718 argv[0], argv[optind - 1][0], pfound->name); 719 720 nextchar += strlen (nextchar); 721 722 optopt = pfound->val; 723 return '?'; 724 } 725 } 726 } 727 else if (pfound->has_arg == 1) 728 { 729 if (optind < argc) 730 optarg = argv[optind++]; 731 else 732 { 733 if (opterr) 734 fprintf (stderr, 735 _("%s: option `%s' requires an argument\n"), 736 argv[0], argv[optind - 1]); 737 nextchar += strlen (nextchar); 738 optopt = pfound->val; 739 return optstring[0] == ':' ? ':' : '?'; 740 } 741 } 742 nextchar += strlen (nextchar); 743 if (longind != NULL) 744 *longind = option_index; 745 if (pfound->flag) 746 { 747 *(pfound->flag) = pfound->val; 748 return 0; 749 } 750 return pfound->val; 751 } 752 753 /* Can't find it as a long option. If this is not getopt_long_only, 754 or the option starts with '--' or is not a valid short 755 option, then it's an error. 756 Otherwise interpret it as a short option. */ 757 if (!long_only || argv[optind][1] == '-' 758 || my_index (optstring, *nextchar) == NULL) 759 { 760 if (opterr) 761 { 762 if (argv[optind][1] == '-') 763 /* --option */ 764 fprintf (stderr, _("%s: unrecognized option `--%s'\n"), 765 argv[0], nextchar); 766 else 767 /* +option or -option */ 768 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), 769 argv[0], argv[optind][0], nextchar); 770 } 771 nextchar = (char *) ""; 772 optind++; 773 optopt = 0; 774 return '?'; 775 } 776 } 777 778 /* Look at and handle the next short option-character. */ 779 780 { 781 char c = *nextchar++; 782 char *temp = my_index (optstring, c); 783 784 /* Increment `optind' when we start to process its last character. */ 785 if (*nextchar == '\0') 786 ++optind; 787 788 if (temp == NULL || c == ':') 789 { 790 if (opterr) 791 { 792 if (posixly_correct) 793 /* 1003.2 specifies the format of this message. */ 794 fprintf (stderr, _("%s: illegal option -- %c\n"), 795 argv[0], c); 796 else 797 fprintf (stderr, _("%s: invalid option -- %c\n"), 798 argv[0], c); 799 } 800 optopt = c; 801 return '?'; 802 } 803 /* Convenience. Treat POSIX -W foo same as long option --foo */ 804 if (temp[0] == 'W' && temp[1] == ';') 805 { 806 char *nameend; 807 const struct option *p; 808 const struct option *pfound = NULL; 809 int exact = 0; 810 int ambig = 0; 811 int indfound = 0; 812 int option_index; 813 814 /* This is an option that requires an argument. */ 815 if (*nextchar != '\0') 816 { 817 optarg = nextchar; 818 /* If we end this ARGV-element by taking the rest as an arg, 819 we must advance to the next element now. */ 820 optind++; 821 } 822 else if (optind == argc) 823 { 824 if (opterr) 825 { 826 /* 1003.2 specifies the format of this message. */ 827 fprintf (stderr, _("%s: option requires an argument -- %c\n"), 828 argv[0], c); 829 } 830 optopt = c; 831 if (optstring[0] == ':') 832 c = ':'; 833 else 834 c = '?'; 835 return c; 836 } 837 else 838 /* We already incremented `optind' once; 839 increment it again when taking next ARGV-elt as argument. */ 840 optarg = argv[optind++]; 841 842 /* optarg is now the argument, see if it's in the 843 table of longopts. */ 844 845 for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) 846 /* Do nothing. */ ; 847 848 /* Test all long options for either exact match 849 or abbreviated matches. */ 850 for (p = longopts, option_index = 0; p->name; p++, option_index++) 851 if (!strncmp (p->name, nextchar, nameend - nextchar)) 852 { 853 if ((unsigned int) (nameend - nextchar) == strlen (p->name)) 854 { 855 /* Exact match found. */ 856 pfound = p; 857 indfound = option_index; 858 exact = 1; 859 break; 860 } 861 else if (pfound == NULL) 862 { 863 /* First nonexact match found. */ 864 pfound = p; 865 indfound = option_index; 866 } 867 else 868 /* Second or later nonexact match found. */ 869 ambig = 1; 870 } 871 if (ambig && !exact) 872 { 873 if (opterr) 874 fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), 875 argv[0], argv[optind]); 876 nextchar += strlen (nextchar); 877 optind++; 878 return '?'; 879 } 880 if (pfound != NULL) 881 { 882 option_index = indfound; 883 if (*nameend) 884 { 885 /* Don't test has_arg with >, because some C compilers don't 886 allow it to be used on enums. */ 887 if (pfound->has_arg) 888 optarg = nameend + 1; 889 else 890 { 891 if (opterr) 892 fprintf (stderr, _("\ 893 %s: option `-W %s' doesn't allow an argument\n"), 894 argv[0], pfound->name); 895 896 nextchar += strlen (nextchar); 897 return '?'; 898 } 899 } 900 else if (pfound->has_arg == 1) 901 { 902 if (optind < argc) 903 optarg = argv[optind++]; 904 else 905 { 906 if (opterr) 907 fprintf (stderr, 908 _("%s: option `%s' requires an argument\n"), 909 argv[0], argv[optind - 1]); 910 nextchar += strlen (nextchar); 911 return optstring[0] == ':' ? ':' : '?'; 912 } 913 } 914 nextchar += strlen (nextchar); 915 if (longind != NULL) 916 *longind = option_index; 917 if (pfound->flag) 918 { 919 *(pfound->flag) = pfound->val; 920 return 0; 921 } 922 return pfound->val; 923 } 924 nextchar = NULL; 925 return 'W'; /* Let the application handle it. */ 926 } 927 if (temp[1] == ':') 928 { 929 if (temp[2] == ':') 930 { 931 /* This is an option that accepts an argument optionally. */ 932 if (*nextchar != '\0') 933 { 934 optarg = nextchar; 935 optind++; 936 } 937 else 938 optarg = NULL; 939 nextchar = NULL; 940 } 941 else 942 { 943 /* This is an option that requires an argument. */ 944 if (*nextchar != '\0') 945 { 946 optarg = nextchar; 947 /* If we end this ARGV-element by taking the rest as an arg, 948 we must advance to the next element now. */ 949 optind++; 950 } 951 else if (optind == argc) 952 { 953 if (opterr) 954 { 955 /* 1003.2 specifies the format of this message. */ 956 fprintf (stderr, 957 _("%s: option requires an argument -- %c\n"), 958 argv[0], c); 959 } 960 optopt = c; 961 if (optstring[0] == ':') 962 c = ':'; 963 else 964 c = '?'; 965 } 966 else 967 /* We already incremented `optind' once; 968 increment it again when taking next ARGV-elt as argument. */ 969 optarg = argv[optind++]; 970 nextchar = NULL; 971 } 972 } 973 return c; 974 } 975 } 976 977 int 978 getopt (int argc, char *const *argv, 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 /* Not ELIDE_CODE. */ 987 988 #ifdef TEST 990 991 /* Compile with -DTEST to make an executable for use in testing 992 the above definition of `getopt'. */ 993 994 int 995 main (int argc, char **argv) 996 { 997 int c; 998 int digit_optind = 0; 999 1000 while (1) 1001 { 1002 int this_option_optind = optind ? optind : 1; 1003 1004 c = getopt (argc, argv, "abc:d:0123456789"); 1005 if (c == -1) 1006 break; 1007 1008 switch (c) 1009 { 1010 case '0': 1011 case '1': 1012 case '2': 1013 case '3': 1014 case '4': 1015 case '5': 1016 case '6': 1017 case '7': 1018 case '8': 1019 case '9': 1020 if (digit_optind != 0 && digit_optind != this_option_optind) 1021 printf ("digits occur in two different argv-elements.\n"); 1022 digit_optind = this_option_optind; 1023 printf ("option %c\n", c); 1024 break; 1025 1026 case 'a': 1027 printf ("option a\n"); 1028 break; 1029 1030 case 'b': 1031 printf ("option b\n"); 1032 break; 1033 1034 case 'c': 1035 printf ("option c with value `%s'\n", optarg); 1036 break; 1037 1038 case '?': 1039 break; 1040 1041 default: 1042 printf ("?? getopt returned character code 0%o ??\n", c); 1043 } 1044 } 1045 1046 if (optind < argc) 1047 { 1048 printf ("non-option ARGV-elements: "); 1049 while (optind < argc) 1050 printf ("%s ", argv[optind++]); 1051 printf ("\n"); 1052 } 1053 1054 exit (0); 1055 } 1056 1057 #endif /* TEST */ 1058
