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