src/getopt.c

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