posix/getopt.c

   1 /* Getopt for GNU.
   2    NOTE: getopt is 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-1996,1998-2004,2008,2009,2010
   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, int posixly_correct)
 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 = 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, int posixly_correct)
 396 {
 397   int print_errors = d->opterr;
 398
 399   if (argc < 1)
 400     return -1;
 401
 402   d->optarg = NULL;
 403
 404   if (d->optind == 0 || !d->__initialized)
 405     {
 406       if (d->optind == 0)
 407         d->optind = 1;  /* Don't scan ARGV[0], the program name.  */
 408       optstring = _getopt_initialize (argc, argv, optstring, d,
 409                                       posixly_correct);
 410       d->__initialized = 1;
 411     }
 412   else if (optstring[0] == '-' || optstring[0] == '+')
 413     optstring++;
 414   if (optstring[0] == ':')
 415     print_errors = 0;
 416
 417   /* Test whether ARGV[optind] points to a non-option argument.
 418      Either it does not have option syntax, or there is an environment flag
 419      from the shell indicating it is not an option.  The later information
 420      is only used when the used in the GNU libc.  */
 421 #if defined _LIBC && defined USE_NONOPTION_FLAGS
 422 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
 423                       || (d->optind < d->__nonoption_flags_len                \
 424                           && __getopt_nonoption_flags[d->optind] == '1'))
 425 #else
 426 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
 427 #endif
 428
 429   if (d->__nextchar == NULL || *d->__nextchar == '\0')
 430     {
 431       /* Advance to the next ARGV-element.  */
 432
 433       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
 434          moved back by the user (who may also have changed the arguments).  */
 435       if (d->__last_nonopt > d->optind)
 436         d->__last_nonopt = d->optind;
 437       if (d->__first_nonopt > d->optind)
 438         d->__first_nonopt = d->optind;
 439
 440       if (d->__ordering == PERMUTE)
 441         {
 442           /* If we have just processed some options following some non-options,
 443              exchange them so that the options come first.  */
 444
 445           if (d->__first_nonopt != d->__last_nonopt
 446               && d->__last_nonopt != d->optind)
 447             exchange ((char **) argv, d);
 448           else if (d->__last_nonopt != d->optind)
 449             d->__first_nonopt = d->optind;
 450
 451           /* Skip any additional non-options
 452              and extend the range of non-options previously skipped.  */
 453
 454           while (d->optind < argc && NONOPTION_P)
 455             d->optind++;
 456           d->__last_nonopt = d->optind;
 457         }
 458
 459       /* The special ARGV-element `--' means premature end of options.
 460          Skip it like a null option,
 461          then exchange with previous non-options as if it were an option,
 462          then skip everything else like a non-option.  */
 463
 464       if (d->optind != argc && !strcmp (argv[d->optind], "--"))
 465         {
 466           d->optind++;
 467
 468           if (d->__first_nonopt != d->__last_nonopt
 469               && d->__last_nonopt != d->optind)
 470             exchange ((char **) argv, d);
 471           else if (d->__first_nonopt == d->__last_nonopt)
 472             d->__first_nonopt = d->optind;
 473           d->__last_nonopt = argc;
 474
 475           d->optind = argc;
 476         }
 477
 478       /* If we have done all the ARGV-elements, stop the scan
 479          and back over any non-options that we skipped and permuted.  */
 480
 481       if (d->optind == argc)
 482         {
 483           /* Set the next-arg-index to point at the non-options
 484              that we previously skipped, so the caller will digest them.  */
 485           if (d->__first_nonopt != d->__last_nonopt)
 486             d->optind = d->__first_nonopt;
 487           return -1;
 488         }
 489
 490       /* If we have come to a non-option and did not permute it,
 491          either stop the scan or describe it to the caller and pass it by.  */
 492
 493       if (NONOPTION_P)
 494         {
 495           if (d->__ordering == REQUIRE_ORDER)
 496             return -1;
 497           d->optarg = argv[d->optind++];
 498           return 1;
 499         }
 500
 501       /* We have found another option-ARGV-element.
 502          Skip the initial punctuation.  */
 503
 504       d->__nextchar = (argv[d->optind] + 1
 505                   + (longopts != NULL && argv[d->optind][1] == '-'));
 506     }
 507
 508   /* Decode the current option-ARGV-element.  */
 509
 510   /* Check whether the ARGV-element is a long option.
 511
 512      If long_only and the ARGV-element has the form "-f", where f is
 513      a valid short option, don't consider it an abbreviated form of
 514      a long option that starts with f.  Otherwise there would be no
 515      way to give the -f short option.
 516
 517      On the other hand, if there's a long option "fubar" and
 518      the ARGV-element is "-fu", do consider that an abbreviation of
 519      the long option, just like "--fu", and not "-f" with arg "u".
 520
 521      This distinction seems to be the most useful approach.  */
 522
 523   if (longopts != NULL
 524       && (argv[d->optind][1] == '-'
 525           || (long_only && (argv[d->optind][2]
 526                             || !strchr (optstring, argv[d->optind][1])))))
 527     {
 528       char *nameend;
 529       const struct option *p;
 530       const struct option *pfound = NULL;
 531       int exact = 0;
 532       int ambig = 0;
 533       int indfound = -1;
 534       int option_index;
 535
 536       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
 537         /* Do nothing.  */ ;
 538
 539       /* Test all long options for either exact match
 540          or abbreviated matches.  */
 541       for (p = longopts, option_index = 0; p->name; p++, option_index++)
 542         if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
 543           {
 544             if ((unsigned int) (nameend - d->__nextchar)
 545                 == (unsigned int) strlen (p->name))
 546               {
 547                 /* Exact match found.  */
 548                 pfound = p;
 549                 indfound = option_index;
 550                 exact = 1;
 551                 break;
 552               }
 553             else if (pfound == NULL)
 554               {
 555                 /* First nonexact match found.  */
 556                 pfound = p;
 557                 indfound = option_index;
 558               }
 559             else if (long_only
 560                      || pfound->has_arg != p->has_arg
 561                      || pfound->flag != p->flag
 562                      || pfound->val != p->val)
 563               /* Second or later nonexact match found.  */
 564               ambig = 1;
 565           }
 566
 567       if (ambig && !exact)
 568         {
 569           if (print_errors)
 570             {
 571 #if defined _LIBC && defined USE_IN_LIBIO
 572               char *buf;
 573
 574               if (__asprintf (&buf, _("%s: option '%s' is ambiguous\n"),
 575                               argv[0], argv[d->optind]) >= 0)
 576                 {
 577                   _IO_flockfile (stderr);
 578
 579                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 580                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 581
 582                   __fxprintf (NULL, "%s", buf);
 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                           __fxprintf (NULL, "%s", buf);
 658
 659                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 660                           _IO_funlockfile (stderr);
 661
 662                           free (buf);
 663                         }
 664 #endif
 665                     }
 666
 667                   d->__nextchar += strlen (d->__nextchar);
 668
 669                   d->optopt = pfound->val;
 670                   return '?';
 671                 }
 672             }
 673           else if (pfound->has_arg == 1)
 674             {
 675               if (d->optind < argc)
 676                 d->optarg = argv[d->optind++];
 677               else
 678                 {
 679                   if (print_errors)
 680                     {
 681 #if defined _LIBC && defined USE_IN_LIBIO
 682                       char *buf;
 683
 684                       if (__asprintf (&buf, _("\
 685 %s: option '--%s' requires an argument\n"),
 686                                       argv[0], pfound->name) >= 0)
 687                         {
 688                           _IO_flockfile (stderr);
 689
 690                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 691                           ((_IO_FILE *) stderr)->_flags2
 692                             |= _IO_FLAGS2_NOTCANCEL;
 693
 694                           __fxprintf (NULL, "%s", buf);
 695
 696                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 697                           _IO_funlockfile (stderr);
 698
 699                           free (buf);
 700                         }
 701 #else
 702                       fprintf (stderr,
 703                                _("%s: option '--%s' requires an argument\n"),
 704                                argv[0], pfound->name);
 705 #endif
 706                     }
 707                   d->__nextchar += strlen (d->__nextchar);
 708                   d->optopt = pfound->val;
 709                   return optstring[0] == ':' ? ':' : '?';
 710                 }
 711             }
 712           d->__nextchar += strlen (d->__nextchar);
 713           if (longind != NULL)
 714             *longind = option_index;
 715           if (pfound->flag)
 716             {
 717               *(pfound->flag) = pfound->val;
 718               return 0;
 719             }
 720           return pfound->val;
 721         }
 722
 723       /* Can't find it as a long option.  If this is not getopt_long_only,
 724          or the option starts with '--' or is not a valid short
 725          option, then it's an error.
 726          Otherwise interpret it as a short option.  */
 727       if (!long_only || argv[d->optind][1] == '-'
 728           || strchr (optstring, *d->__nextchar) == NULL)
 729         {
 730           if (print_errors)
 731             {
 732 #if defined _LIBC && defined USE_IN_LIBIO
 733               char *buf;
 734               int n;
 735 #endif
 736
 737               if (argv[d->optind][1] == '-')
 738                 {
 739                   /* --option */
 740 #if defined _LIBC && defined USE_IN_LIBIO
 741                   n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
 742                                   argv[0], d->__nextchar);
 743 #else
 744                   fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
 745                            argv[0], d->__nextchar);
 746 #endif
 747                 }
 748               else
 749                 {
 750                   /* +option or -option */
 751 #if defined _LIBC && defined USE_IN_LIBIO
 752                   n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
 753                                   argv[0], argv[d->optind][0], d->__nextchar);
 754 #else
 755                   fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
 756                            argv[0], argv[d->optind][0], d->__nextchar);
 757 #endif
 758                 }
 759
 760 #if defined _LIBC && defined USE_IN_LIBIO
 761               if (n >= 0)
 762                 {
 763                   _IO_flockfile (stderr);
 764
 765                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 766                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 767
 768                   __fxprintf (NULL, "%s", buf);
 769
 770                   ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 771                   _IO_funlockfile (stderr);
 772
 773                   free (buf);
 774                 }
 775 #endif
 776             }
 777           d->__nextchar = (char *) "";
 778           d->optind++;
 779           d->optopt = 0;
 780           return '?';
 781         }
 782     }
 783
 784   /* Look at and handle the next short option-character.  */
 785
 786   {
 787     char c = *d->__nextchar++;
 788     char *temp = strchr (optstring, c);
 789
 790     /* Increment `optind' when we start to process its last character.  */
 791     if (*d->__nextchar == '\0')
 792       ++d->optind;
 793
 794     if (temp == NULL || c == ':' || c == ';')
 795       {
 796         if (print_errors)
 797           {
 798 #if defined _LIBC && defined USE_IN_LIBIO
 799             char *buf;
 800             int n;
 801 #endif
 802
 803 #if defined _LIBC && defined USE_IN_LIBIO
 804             n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
 805                             argv[0], c);
 806 #else
 807             fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
 808 #endif
 809
 810 #if defined _LIBC && defined USE_IN_LIBIO
 811             if (n >= 0)
 812               {
 813                 _IO_flockfile (stderr);
 814
 815                 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 816                 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 817
 818                 __fxprintf (NULL, "%s", buf);
 819
 820                 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 821                 _IO_funlockfile (stderr);
 822
 823                 free (buf);
 824               }
 825 #endif
 826           }
 827         d->optopt = c;
 828         return '?';
 829       }
 830     /* Convenience. Treat POSIX -W foo same as long option --foo */
 831     if (temp[0] == 'W' && temp[1] == ';')
 832       {
 833         char *nameend;
 834         const struct option *p;
 835         const struct option *pfound = NULL;
 836         int exact = 0;
 837         int ambig = 0;
 838         int indfound = 0;
 839         int option_index;
 840
 841         /* This is an option that requires an argument.  */
 842         if (*d->__nextchar != '\0')
 843           {
 844             d->optarg = d->__nextchar;
 845             /* If we end this ARGV-element by taking the rest as an arg,
 846                we must advance to the next element now.  */
 847             d->optind++;
 848           }
 849         else if (d->optind == argc)
 850           {
 851             if (print_errors)
 852               {
 853 #if defined _LIBC && defined USE_IN_LIBIO
 854                 char *buf;
 855
 856                 if (__asprintf (&buf,
 857                                 _("%s: option requires an argument -- '%c'\n"),
 858                                 argv[0], c) >= 0)
 859                   {
 860                     _IO_flockfile (stderr);
 861
 862                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 863                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 864
 865                     __fxprintf (NULL, "%s", buf);
 866
 867                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 868                     _IO_funlockfile (stderr);
 869
 870                     free (buf);
 871                   }
 872 #else
 873                 fprintf (stderr,
 874                          _("%s: option requires an argument -- '%c'\n"),
 875                          argv[0], c);
 876 #endif
 877               }
 878             d->optopt = c;
 879             if (optstring[0] == ':')
 880               c = ':';
 881             else
 882               c = '?';
 883             return c;
 884           }
 885         else
 886           /* We already incremented `d->optind' once;
 887              increment it again when taking next ARGV-elt as argument.  */
 888           d->optarg = argv[d->optind++];
 889
 890         /* optarg is now the argument, see if it's in the
 891            table of longopts.  */
 892
 893         for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
 894              nameend++)
 895           /* Do nothing.  */ ;
 896
 897         /* Test all long options for either exact match
 898            or abbreviated matches.  */
 899         for (p = longopts, option_index = 0; p->name; p++, option_index++)
 900           if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
 901             {
 902               if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
 903                 {
 904                   /* Exact match found.  */
 905                   pfound = p;
 906                   indfound = option_index;
 907                   exact = 1;
 908                   break;
 909                 }
 910               else if (pfound == NULL)
 911                 {
 912                   /* First nonexact match found.  */
 913                   pfound = p;
 914                   indfound = option_index;
 915                 }
 916               else if (long_only
 917                        || pfound->has_arg != p->has_arg
 918                        || pfound->flag != p->flag
 919                        || pfound->val != p->val)
 920                 /* Second or later nonexact match found.  */
 921                 ambig = 1;
 922             }
 923         if (ambig && !exact)
 924           {
 925             if (print_errors)
 926               {
 927 #if defined _LIBC && defined USE_IN_LIBIO
 928                 char *buf;
 929
 930                 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
 931                                 argv[0], d->optarg) >= 0)
 932                   {
 933                     _IO_flockfile (stderr);
 934
 935                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 936                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 937
 938                     __fxprintf (NULL, "%s", buf);
 939
 940                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 941                     _IO_funlockfile (stderr);
 942
 943                     free (buf);
 944                   }
 945 #else
 946                 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
 947                          argv[0], d->optarg);
 948 #endif
 949               }
 950             d->__nextchar += strlen (d->__nextchar);
 951             d->optind++;
 952             return '?';
 953           }
 954         if (pfound != NULL)
 955           {
 956             option_index = indfound;
 957             if (*nameend)
 958               {
 959                 /* Don't test has_arg with >, because some C compilers don't
 960                    allow it to be used on enums.  */
 961                 if (pfound->has_arg)
 962                   d->optarg = nameend + 1;
 963                 else
 964                   {
 965                     if (print_errors)
 966                       {
 967 #if defined _LIBC && defined USE_IN_LIBIO
 968                         char *buf;
 969
 970                         if (__asprintf (&buf, _("\
 971 %s: option '-W %s' doesn't allow an argument\n"),
 972                                         argv[0], pfound->name) >= 0)
 973                           {
 974                             _IO_flockfile (stderr);
 975
 976                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 977                             ((_IO_FILE *) stderr)->_flags2
 978                               |= _IO_FLAGS2_NOTCANCEL;
 979
 980                             __fxprintf (NULL, "%s", buf);
 981
 982                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 983                             _IO_funlockfile (stderr);
 984
 985                             free (buf);
 986                           }
 987 #else
 988                         fprintf (stderr, _("\
 989 %s: option '-W %s' doesn't allow an argument\n"),
 990                                  argv[0], pfound->name);
 991 #endif
 992                       }
 993
 994                     d->__nextchar += strlen (d->__nextchar);
 995                     return '?';
 996                   }
 997               }
 998             else if (pfound->has_arg == 1)
 999               {
1000                 if (d->optind < argc)
1001                   d->optarg = argv[d->optind++];
1002                 else
1003                   {
1004                     if (print_errors)
1005                       {
1006 #if defined _LIBC && defined USE_IN_LIBIO
1007                         char *buf;
1008
1009                         if (__asprintf (&buf, _("\
1010 %s: option '-W %s' requires an argument\n"),
1011                                         argv[0], pfound->name) >= 0)
1012                           {
1013                             _IO_flockfile (stderr);
1014
1015                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1016                             ((_IO_FILE *) stderr)->_flags2
1017                               |= _IO_FLAGS2_NOTCANCEL;
1018
1019                             __fxprintf (NULL, "%s", buf);
1020
1021                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1022                             _IO_funlockfile (stderr);
1023
1024                             free (buf);
1025                           }
1026 #else
1027                         fprintf (stderr, _("\
1028 %s: option '-W %s' requires an argument\n"),
1029                                  argv[0], pfound->name);
1030 #endif
1031                       }
1032                     d->__nextchar += strlen (d->__nextchar);
1033                     return optstring[0] == ':' ? ':' : '?';
1034                   }
1035               }
1036             else
1037               d->optarg = NULL;
1038             d->__nextchar += strlen (d->__nextchar);
1039             if (longind != NULL)
1040               *longind = option_index;
1041             if (pfound->flag)
1042               {
1043                 *(pfound->flag) = pfound->val;
1044                 return 0;
1045               }
1046             return pfound->val;
1047           }
1048           d->__nextchar = NULL;
1049           return 'W';   /* Let the application handle it.   */
1050       }
1051     if (temp[1] == ':')
1052       {
1053         if (temp[2] == ':')
1054           {
1055             /* This is an option that accepts an argument optionally.  */
1056             if (*d->__nextchar != '\0')
1057               {
1058                 d->optarg = d->__nextchar;
1059                 d->optind++;
1060               }
1061             else
1062               d->optarg = NULL;
1063             d->__nextchar = NULL;
1064           }
1065         else
1066           {
1067             /* This is an option that requires an argument.  */
1068             if (*d->__nextchar != '\0')
1069               {
1070                 d->optarg = d->__nextchar;
1071                 /* If we end this ARGV-element by taking the rest as an arg,
1072                    we must advance to the next element now.  */
1073                 d->optind++;
1074               }
1075             else if (d->optind == argc)
1076               {
1077                 if (print_errors)
1078                   {
1079 #if defined _LIBC && defined USE_IN_LIBIO
1080                     char *buf;
1081
1082                     if (__asprintf (&buf, _("\
1083 %s: option requires an argument -- '%c'\n"),
1084                                     argv[0], c) >= 0)
1085                       {
1086                         _IO_flockfile (stderr);
1087
1088                         int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1089                         ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1090
1091                         __fxprintf (NULL, "%s", buf);
1092
1093                         ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1094                         _IO_funlockfile (stderr);
1095
1096                         free (buf);
1097                       }
1098 #else
1099                     fprintf (stderr,
1100                              _("%s: option requires an argument -- '%c'\n"),
1101                              argv[0], c);
1102 #endif
1103                   }
1104                 d->optopt = c;
1105                 if (optstring[0] == ':')
1106                   c = ':';
1107                 else
1108                   c = '?';
1109               }
1110             else
1111               /* We already incremented `optind' once;
1112                  increment it again when taking next ARGV-elt as argument.  */
1113               d->optarg = argv[d->optind++];
1114             d->__nextchar = NULL;
1115           }
1116       }
1117     return c;
1118   }
1119 }
1120
1121 int
1122 _getopt_internal (int argc, char *const *argv, const char *optstring,
1123                   const struct option *longopts, int *longind, int long_only,
1124                   int posixly_correct)
1125 {
1126   int result;
1127
1128   getopt_data.optind = optind;
1129   getopt_data.opterr = opterr;
1130
1131   result = _getopt_internal_r (argc, argv, optstring, longopts,
1132                                longind, long_only, &getopt_data,
1133                                posixly_correct);
1134
1135   optind = getopt_data.optind;
1136   optarg = getopt_data.optarg;
1137   optopt = getopt_data.optopt;
1138
1139   return result;
1140 }
1141
1142 int
1143 getopt (int argc, char *const *argv, const char *optstring)
1144 {
1145   return _getopt_internal (argc, argv, optstring,
1146                            (const struct option *) 0,
1147                            (int *) 0,
1148                            0, 0);
1149 }
1150
1151 #ifdef _LIBC
1152 int
1153 __posix_getopt (int argc, char *const *argv, const char *optstring)
1154 {
1155   return _getopt_internal (argc, argv, optstring,
1156                            (const struct option *) 0,
1157                            (int *) 0,
1158                            0, 1);
1159 }
1160 #endif
1161
1162 #endif  /* Not ELIDE_CODE.  */
1163 \f
1164 #ifdef TEST
1165
1166 /* Compile with -DTEST to make an executable for use in testing
1167    the above definition of `getopt'.  */
1168
1169 int
1170 main (int argc, char **argv)
1171 {
1172   int c;
1173   int digit_optind = 0;
1174
1175   while (1)
1176     {
1177       int this_option_optind = optind ? optind : 1;
1178
1179       c = getopt (argc, argv, "abc:d:0123456789");
1180       if (c == -1)
1181         break;
1182
1183       switch (c)
1184         {
1185         case '0':
1186         case '1':
1187         case '2':
1188         case '3':
1189         case '4':
1190         case '5':
1191         case '6':
1192         case '7':
1193         case '8':
1194         case '9':
1195           if (digit_optind != 0 && digit_optind != this_option_optind)
1196             printf ("digits occur in two different argv-elements.\n");
1197           digit_optind = this_option_optind;
1198           printf ("option %c\n", c);
1199           break;
1200
1201         case 'a':
1202           printf ("option a\n");
1203           break;
1204
1205         case 'b':
1206           printf ("option b\n");
1207           break;
1208
1209         case 'c':
1210           printf ("option c with value '%s'\n", optarg);
1211           break;
1212
1213         case '?':
1214           break;
1215
1216         default:
1217           printf ("?? getopt returned character code 0%o ??\n", c);
1218         }
1219     }
1220
1221   if (optind < argc)
1222     {
1223       printf ("non-option ARGV-elements: ");
1224       while (optind < argc)
1225         printf ("%s ", argv[optind++]);
1226       printf ("\n");
1227     }
1228
1229   exit (0);
1230 }
1231
1232 #endif /* TEST */