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