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