git.cworth.org Git - tar/blob - gnu/getopt.c

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