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