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