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