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