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