getopt.c 32.7 KB
Newer Older
1
/* Getopt for GNU.
2 3 4
   NOTE: getopt is now part of the C library, so if you don't know what
   "Keep this file name-space clean" means, talk to drepper@gnu.org
   before changing it!
5 6
   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004
	Free Software Foundation, Inc.
7
   This file is part of the GNU C Library.
8

9 10 11 12
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
13 14 15 16 17 18

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

19 20
   You should have received a copy of the GNU General Public License along
   with this program; if not, write to the Free Software Foundation,
Lute Kamstra's avatar
Lute Kamstra committed
21
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
22 23 24 25

/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
   Ditto for AIX 3.2 and <stdlib.h>.  */
#ifndef _NO_PROTO
26
# define _NO_PROTO
27 28 29
#endif

#ifdef HAVE_CONFIG_H
30
# include <config.h>
31 32
#endif

33 34 35 36 37 38 39
#include <stdio.h>

/* This needs to come after some library #include
   to get __GNU_LIBRARY__ defined.  */
#ifdef	__GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
   contain conflicting prototypes for getopt.  */
40 41
# include <stdlib.h>
# include <unistd.h>
42 43
#endif	/* GNU C library.  */

44 45
#include <string.h>

46
#ifdef VMS
47
# include <unixlib.h>
48 49
#endif

50
#ifdef _LIBC
51
# include <libintl.h>
52 53 54 55
#else
# include "gettext.h"
# define _(msgid) gettext (msgid)
#endif
56 57 58 59 60 61 62

#if defined _LIBC && defined USE_IN_LIBIO
# include <wchar.h>
#endif

#ifndef attribute_hidden
# define attribute_hidden
63 64
#endif

65 66
/* Unlike standard Unix `getopt', functions like `getopt_long'
   let the user intersperse the options with the other arguments.
67

68
   As `getopt_long' works, it permutes the elements of ARGV so that,
69 70 71
   when it is done, all the options precede everything else.  Thus
   all application programs are extended to handle flexible argument order.

72 73 74
   Using `getopt' or setting the environment variable POSIXLY_CORRECT
   disables permutation.
   Then the application's behavior is completely standard.
75 76 77 78 79

   GNU application programs can use a third alternative mode in which
   they can distinguish the relative order of options and other arguments.  */

#include "getopt.h"
80
#include "getopt_int.h"
81 82 83 84 85 86 87

/* For communication from `getopt' to the caller.
   When `getopt' finds an option that takes an argument,
   the argument value is returned here.
   Also, when `ordering' is RETURN_IN_ORDER,
   each non-option ARGV-element is returned here.  */

88
char *optarg;
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
   and for communication between successive calls to `getopt'.

   On entry to `getopt', zero means this is the first call; initialize.

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

/* 1003.2 says this must be 1 before any call.  */
int optind = 1;

/* Callers store zero here to inhibit the error message
   for unrecognized options.  */

int opterr = 1;

/* Set to an option character which was unrecognized.
   This must be initialized on some systems to avoid linking in the
   system's own getopt implementation.  */

int optopt = '?';

116
/* Keep a global copy of all internal members of getopt_data.  */
117

118
static struct _getopt_data getopt_data;
119 120


121
#ifndef __GNU_LIBRARY__
122

123 124 125
/* Avoid depending on library functions or files
   whose names are inconsistent.  */

126 127 128
#ifndef getenv
extern char *getenv ();
#endif
129 130 131 132

#endif /* not __GNU_LIBRARY__ */

#ifdef _LIBC
133 134 135 136 137 138
/* Stored original parameters.
   XXX This is no good solution.  We should rather copy the args so
   that we can compare them later.  But we must not use malloc(3).  */
extern int __libc_argc;
extern char **__libc_argv;

139 140 141
/* Bash 2.0 gives us an environment variable containing flags
   indicating ARGV elements that should not be considered arguments.  */

142
# ifdef USE_NONOPTION_FLAGS
143 144
/* Defined in getopt_init.c  */
extern char *__getopt_nonoption_flags;
145
# endif
146

147 148
# ifdef USE_NONOPTION_FLAGS
#  define SWAP_FLAGS(ch1, ch2) \
149
  if (d->__nonoption_flags_len > 0)					      \
150 151 152 153 154
    {									      \
      char __tmp = __getopt_nonoption_flags[ch1];			      \
      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
      __getopt_nonoption_flags[ch2] = __tmp;				      \
    }
155 156 157
# else
#  define SWAP_FLAGS(ch1, ch2)
# endif
158 159 160 161 162 163 164 165 166 167 168 169 170 171
#else	/* !_LIBC */
# define SWAP_FLAGS(ch1, ch2)
#endif	/* _LIBC */

/* Exchange two adjacent subsequences of ARGV.
   One subsequence is elements [first_nonopt,last_nonopt)
   which contains all the non-options that have been skipped so far.
   The other is elements [last_nonopt,optind), which contains all
   the options processed since those non-options were skipped.

   `first_nonopt' and `last_nonopt' are relocated so that they describe
   the new indices of the non-options in ARGV after they are moved.  */

static void
172
exchange (char **argv, struct _getopt_data *d)
173
{
174 175 176
  int bottom = d->__first_nonopt;
  int middle = d->__last_nonopt;
  int top = d->optind;
177 178 179 180 181 182 183
  char *tem;

  /* Exchange the shorter segment with the far end of the longer segment.
     That puts the shorter segment into the right place.
     It leaves the longer segment in the right place overall,
     but it consists of two parts that need to be swapped next.  */

184
#if defined _LIBC && defined USE_NONOPTION_FLAGS
185 186 187
  /* First make sure the handling of the `__getopt_nonoption_flags'
     string can work normally.  Our top argument must be in the range
     of the string.  */
188
  if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
189 190 191 192 193
    {
      /* We must extend the array.  The user plays games with us and
	 presents new arguments.  */
      char *new_str = malloc (top + 1);
      if (new_str == NULL)
194
	d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
195 196
      else
	{
197
	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
198 199 200
			     d->__nonoption_flags_max_len),
		  '\0', top + 1 - d->__nonoption_flags_max_len);
	  d->__nonoption_flags_max_len = top + 1;
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	  __getopt_nonoption_flags = new_str;
	}
    }
#endif

  while (top > middle && middle > bottom)
    {
      if (top - middle > middle - bottom)
	{
	  /* Bottom segment is the short one.  */
	  int len = middle - bottom;
	  register int i;

	  /* Swap it with the top part of the top segment.  */
	  for (i = 0; i < len; i++)
	    {
	      tem = argv[bottom + i];
	      argv[bottom + i] = argv[top - (middle - bottom) + i];
	      argv[top - (middle - bottom) + i] = tem;
	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
	    }
	  /* Exclude the moved bottom segment from further swapping.  */
	  top -= len;
	}
      else
	{
	  /* Top segment is the short one.  */
	  int len = top - middle;
	  register int i;

	  /* Swap it with the bottom part of the bottom segment.  */
	  for (i = 0; i < len; i++)
	    {
	      tem = argv[bottom + i];
	      argv[bottom + i] = argv[middle + i];
	      argv[middle + i] = tem;
	      SWAP_FLAGS (bottom + i, middle + i);
	    }
	  /* Exclude the moved top segment from further swapping.  */
	  bottom += len;
	}
    }

  /* Update records for the slots the non-options now occupy.  */

246 247
  d->__first_nonopt += (d->optind - d->__last_nonopt);
  d->__last_nonopt = d->optind;
248 249 250 251 252
}

/* Initialize the internal data when the first call is made.  */

static const char *
253 254
_getopt_initialize (int argc, char **argv, const char *optstring,
		    int posixly_correct, struct _getopt_data *d)
255 256 257 258 259
{
  /* Start processing options with ARGV-element 1 (since ARGV-element 0
     is the program name); the sequence of previously skipped
     non-option ARGV-elements is empty.  */

260
  d->__first_nonopt = d->__last_nonopt = d->optind;
261

262
  d->__nextchar = NULL;
263

264
  d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
265 266 267 268 269

  /* Determine how to handle the ordering of options and nonoptions.  */

  if (optstring[0] == '-')
    {
270
      d->__ordering = RETURN_IN_ORDER;
271 272 273 274
      ++optstring;
    }
  else if (optstring[0] == '+')
    {
275
      d->__ordering = REQUIRE_ORDER;
276 277
      ++optstring;
    }
278 279
  else if (d->__posixly_correct)
    d->__ordering = REQUIRE_ORDER;
280
  else
281
    d->__ordering = PERMUTE;
282

283
#if defined _LIBC && defined USE_NONOPTION_FLAGS
284
  if (!d->__posixly_correct
285
      && argc == __libc_argc && argv == __libc_argv)
286
    {
287
      if (d->__nonoption_flags_max_len == 0)
288 289 290
	{
	  if (__getopt_nonoption_flags == NULL
	      || __getopt_nonoption_flags[0] == '\0')
291
	    d->__nonoption_flags_max_len = -1;
292 293 294
	  else
	    {
	      const char *orig_str = __getopt_nonoption_flags;
295 296 297
	      int len = d->__nonoption_flags_max_len = strlen (orig_str);
	      if (d->__nonoption_flags_max_len < argc)
		d->__nonoption_flags_max_len = argc;
298
	      __getopt_nonoption_flags =
299
		(char *) malloc (d->__nonoption_flags_max_len);
300
	      if (__getopt_nonoption_flags == NULL)
301
		d->__nonoption_flags_max_len = -1;
302
	      else
303
		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
304
			'\0', d->__nonoption_flags_max_len - len);
305 306
	    }
	}
307
      d->__nonoption_flags_len = d->__nonoption_flags_max_len;
308 309
    }
  else
310
    d->__nonoption_flags_len = 0;
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
#endif

  return optstring;
}

/* Scan elements of ARGV (whose length is ARGC) for option characters
   given in OPTSTRING.

   If an element of ARGV starts with '-', and is not exactly "-" or "--",
   then it is an option element.  The characters of this element
   (aside from the initial '-') are option characters.  If `getopt'
   is called repeatedly, it returns successively each of the option characters
   from each of the option elements.

   If `getopt' finds another option character, it returns that character,
   updating `optind' and `nextchar' so that the next call to `getopt' can
   resume the scan with the following option character or ARGV-element.

   If there are no more option characters, `getopt' returns -1.
   Then `optind' is the index in ARGV of the first ARGV-element
   that is not an option.  (The ARGV-elements have been permuted
   so that those that are not options now come last.)

   OPTSTRING is a string containing the legitimate option characters.
   If an option character is seen that is not listed in OPTSTRING,
   return '?' after printing an error message.  If you set `opterr' to
   zero, the error message is suppressed but we still return '?'.

   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
   so the following text in the same ARGV-element, or the text of the following
   ARGV-element, is returned in `optarg'.  Two colons mean an option that
   wants an optional arg; if there is text in the current ARGV-element,
   it is returned in `optarg', otherwise `optarg' is set to zero.

   If OPTSTRING starts with `-' or `+', it requests different methods of
   handling the non-option ARGV-elements.
   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.

   Long-named options begin with `--' instead of `-'.
   Their names may be abbreviated as long as the abbreviation is unique
   or is an exact match for some defined option.  If they have an
   argument, it follows the option name in the same ARGV-element, separated
   from the option name by a `=', or else the in next ARGV-element.
   When `getopt' finds a long-named option, it returns 0 if that option's
   `flag' field is nonzero, the value of the option's `val' field
   if the `flag' field is zero.

   LONGOPTS is a vector of `struct option' terminated by an
   element containing a name which is zero.

   LONGIND returns the index in LONGOPT of the long-named option found.
   It is only valid when a long-named option has been found by the most
   recent call.

   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
366 367 368 369
   long-named options.

   If POSIXLY_CORRECT is nonzero, behave as if the POSIXLY_CORRECT
   environment variable were set.  */
370 371

int
372 373 374
_getopt_internal_r (int argc, char **argv, const char *optstring,
		    const struct option *longopts, int *longind,
		    int long_only, int posixly_correct, struct _getopt_data *d)
375
{
376
  int print_errors = d->opterr;
377 378 379 380 381 382
  if (optstring[0] == ':')
    print_errors = 0;

  if (argc < 1)
    return -1;

383
  d->optarg = NULL;
384

385
  if (d->optind == 0 || !d->__initialized)
386
    {
387 388 389 390 391
      if (d->optind == 0)
	d->optind = 1;	/* Don't scan ARGV[0], the program name.  */
      optstring = _getopt_initialize (argc, argv, optstring,
				      posixly_correct, d);
      d->__initialized = 1;
392 393 394 395 396 397
    }

  /* Test whether ARGV[optind] points to a non-option argument.
     Either it does not have option syntax, or there is an environment flag
     from the shell indicating it is not an option.  The later information
     is only used when the used in the GNU libc.  */
398
#if defined _LIBC && defined USE_NONOPTION_FLAGS
399 400 401
# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
		      || (d->optind < d->__nonoption_flags_len		      \
			  && __getopt_nonoption_flags[d->optind] == '1'))
402
#else
403
# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
404 405
#endif

406
  if (d->__nextchar == NULL || *d->__nextchar == '\0')
407 408 409 410 411
    {
      /* Advance to the next ARGV-element.  */

      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
	 moved back by the user (who may also have changed the arguments).  */
412 413 414 415
      if (d->__last_nonopt > d->optind)
	d->__last_nonopt = d->optind;
      if (d->__first_nonopt > d->optind)
	d->__first_nonopt = d->optind;
416

417
      if (d->__ordering == PERMUTE)
418 419 420 421
	{
	  /* If we have just processed some options following some non-options,
	     exchange them so that the options come first.  */

422 423 424 425 426
	  if (d->__first_nonopt != d->__last_nonopt
	      && d->__last_nonopt != d->optind)
	    exchange ((char **) argv, d);
	  else if (d->__last_nonopt != d->optind)
	    d->__first_nonopt = d->optind;
427 428 429 430

	  /* Skip any additional non-options
	     and extend the range of non-options previously skipped.  */

431 432 433
	  while (d->optind < argc && NONOPTION_P)
	    d->optind++;
	  d->__last_nonopt = d->optind;
434 435 436 437 438 439 440
	}

      /* The special ARGV-element `--' means premature end of options.
	 Skip it like a null option,
	 then exchange with previous non-options as if it were an option,
	 then skip everything else like a non-option.  */

441
      if (d->optind != argc && !strcmp (argv[d->optind], "--"))
442
	{
443
	  d->optind++;
444

445 446 447 448 449 450
	  if (d->__first_nonopt != d->__last_nonopt
	      && d->__last_nonopt != d->optind)
	    exchange ((char **) argv, d);
	  else if (d->__first_nonopt == d->__last_nonopt)
	    d->__first_nonopt = d->optind;
	  d->__last_nonopt = argc;
451

452
	  d->optind = argc;
453 454 455 456 457
	}

      /* If we have done all the ARGV-elements, stop the scan
	 and back over any non-options that we skipped and permuted.  */

458
      if (d->optind == argc)
459 460 461
	{
	  /* Set the next-arg-index to point at the non-options
	     that we previously skipped, so the caller will digest them.  */
462 463
	  if (d->__first_nonopt != d->__last_nonopt)
	    d->optind = d->__first_nonopt;
464 465 466 467 468 469 470 471
	  return -1;
	}

      /* If we have come to a non-option and did not permute it,
	 either stop the scan or describe it to the caller and pass it by.  */

      if (NONOPTION_P)
	{
472
	  if (d->__ordering == REQUIRE_ORDER)
473
	    return -1;
474
	  d->optarg = argv[d->optind++];
475 476 477 478 479 480
	  return 1;
	}

      /* We have found another option-ARGV-element.
	 Skip the initial punctuation.  */

481 482
      d->__nextchar = (argv[d->optind] + 1
		  + (longopts != NULL && argv[d->optind][1] == '-'));
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
    }

  /* Decode the current option-ARGV-element.  */

  /* Check whether the ARGV-element is a long option.

     If long_only and the ARGV-element has the form "-f", where f is
     a valid short option, don't consider it an abbreviated form of
     a long option that starts with f.  Otherwise there would be no
     way to give the -f short option.

     On the other hand, if there's a long option "fubar" and
     the ARGV-element is "-fu", do consider that an abbreviation of
     the long option, just like "--fu", and not "-f" with arg "u".

     This distinction seems to be the most useful approach.  */

  if (longopts != NULL
501 502 503
      && (argv[d->optind][1] == '-'
	  || (long_only && (argv[d->optind][2]
			    || !strchr (optstring, argv[d->optind][1])))))
504 505 506 507 508 509 510 511 512
    {
      char *nameend;
      const struct option *p;
      const struct option *pfound = NULL;
      int exact = 0;
      int ambig = 0;
      int indfound = -1;
      int option_index;

513
      for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
514 515 516 517 518
	/* Do nothing.  */ ;

      /* Test all long options for either exact match
	 or abbreviated matches.  */
      for (p = longopts, option_index = 0; p->name; p++, option_index++)
519
	if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
520
	  {
521
	    if ((unsigned int) (nameend - d->__nextchar)
522 523 524 525 526 527 528 529 530 531 532 533 534 535
		== (unsigned int) strlen (p->name))
	      {
		/* Exact match found.  */
		pfound = p;
		indfound = option_index;
		exact = 1;
		break;
	      }
	    else if (pfound == NULL)
	      {
		/* First nonexact match found.  */
		pfound = p;
		indfound = option_index;
	      }
536 537 538 539
	    else if (long_only
		     || pfound->has_arg != p->has_arg
		     || pfound->flag != p->flag
		     || pfound->val != p->val)
540 541 542 543 544 545
	      /* Second or later nonexact match found.  */
	      ambig = 1;
	  }

      if (ambig && !exact)
	{
546 547 548 549 550 551
	  if (print_errors)
	    {
#if defined _LIBC && defined USE_IN_LIBIO
	      char *buf;

	      if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"),
552
			      argv[0], argv[d->optind]) >= 0)
553
		{
554 555 556 557
		  _IO_flockfile (stderr);

		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
558 559 560 561 562 563

		  if (_IO_fwide (stderr, 0) > 0)
		    __fwprintf (stderr, L"%s", buf);
		  else
		    fputs (buf, stderr);

564 565 566
		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
		  _IO_funlockfile (stderr);

567 568 569 570
		  free (buf);
		}
#else
	      fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
571
		       argv[0], argv[d->optind]);
572 573
#endif
	    }
574 575 576
	  d->__nextchar += strlen (d->__nextchar);
	  d->optind++;
	  d->optopt = 0;
577 578 579 580 581 582
	  return '?';
	}

      if (pfound != NULL)
	{
	  option_index = indfound;
583
	  d->optind++;
584 585 586 587 588
	  if (*nameend)
	    {
	      /* Don't test has_arg with >, because some C compilers don't
		 allow it to be used on enums.  */
	      if (pfound->has_arg)
589
		d->optarg = nameend + 1;
590 591
	      else
		{
592
		  if (print_errors)
593
		    {
594 595 596 597 598
#if defined _LIBC && defined USE_IN_LIBIO
		      char *buf;
		      int n;
#endif

599
		      if (argv[d->optind - 1][1] == '-')
600 601 602 603 604 605 606 607 608 609 610 611
			{
			  /* --option */
#if defined _LIBC && defined USE_IN_LIBIO
			  n = __asprintf (&buf, _("\
%s: option `--%s' doesn't allow an argument\n"),
					  argv[0], pfound->name);
#else
			  fprintf (stderr, _("\
%s: option `--%s' doesn't allow an argument\n"),
				   argv[0], pfound->name);
#endif
			}
612
		      else
613 614 615 616 617
			{
			  /* +option or -option */
#if defined _LIBC && defined USE_IN_LIBIO
			  n = __asprintf (&buf, _("\
%s: option `%c%s' doesn't allow an argument\n"),
618
					  argv[0], argv[d->optind - 1][0],
619 620 621 622
					  pfound->name);
#else
			  fprintf (stderr, _("\
%s: option `%c%s' doesn't allow an argument\n"),
623 624
				   argv[0], argv[d->optind - 1][0],
				   pfound->name);
625 626 627 628 629 630
#endif
			}

#if defined _LIBC && defined USE_IN_LIBIO
		      if (n >= 0)
			{
631 632 633 634 635 636
			  _IO_flockfile (stderr);

			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
			  ((_IO_FILE *) stderr)->_flags2
			    |= _IO_FLAGS2_NOTCANCEL;

637 638 639 640 641
			  if (_IO_fwide (stderr, 0) > 0)
			    __fwprintf (stderr, L"%s", buf);
			  else
			    fputs (buf, stderr);

642 643 644
			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
			  _IO_funlockfile (stderr);

645 646 647
			  free (buf);
			}
#endif
648
		    }
649

650
		  d->__nextchar += strlen (d->__nextchar);
651

652
		  d->optopt = pfound->val;
653 654 655 656 657
		  return '?';
		}
	    }
	  else if (pfound->has_arg == 1)
	    {
658 659
	      if (d->optind < argc)
		d->optarg = argv[d->optind++];
660 661
	      else
		{
662 663 664 665 666 667 668
		  if (print_errors)
		    {
#if defined _LIBC && defined USE_IN_LIBIO
		      char *buf;

		      if (__asprintf (&buf, _("\
%s: option `%s' requires an argument\n"),
669
				      argv[0], argv[d->optind - 1]) >= 0)
670
			{
671 672 673 674 675 676
			  _IO_flockfile (stderr);

			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
			  ((_IO_FILE *) stderr)->_flags2
			    |= _IO_FLAGS2_NOTCANCEL;

677 678 679 680 681
			  if (_IO_fwide (stderr, 0) > 0)
			    __fwprintf (stderr, L"%s", buf);
			  else
			    fputs (buf, stderr);

682 683 684
			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
			  _IO_funlockfile (stderr);

685 686 687 688 689
			  free (buf);
			}
#else
		      fprintf (stderr,
			       _("%s: option `%s' requires an argument\n"),
690
			       argv[0], argv[d->optind - 1]);
691 692
#endif
		    }
693 694
		  d->__nextchar += strlen (d->__nextchar);
		  d->optopt = pfound->val;
695 696 697
		  return optstring[0] == ':' ? ':' : '?';
		}
	    }
698
	  d->__nextchar += strlen (d->__nextchar);
699 700 701 702 703 704 705 706 707 708 709 710 711 712
	  if (longind != NULL)
	    *longind = option_index;
	  if (pfound->flag)
	    {
	      *(pfound->flag) = pfound->val;
	      return 0;
	    }
	  return pfound->val;
	}

      /* Can't find it as a long option.  If this is not getopt_long_only,
	 or the option starts with '--' or is not a valid short
	 option, then it's an error.
	 Otherwise interpret it as a short option.  */
713 714
      if (!long_only || argv[d->optind][1] == '-'
	  || strchr (optstring, *d->__nextchar) == NULL)
715
	{
716
	  if (print_errors)
717
	    {
718 719 720 721 722
#if defined _LIBC && defined USE_IN_LIBIO
	      char *buf;
	      int n;
#endif

723
	      if (argv[d->optind][1] == '-')
724 725 726 727
		{
		  /* --option */
#if defined _LIBC && defined USE_IN_LIBIO
		  n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"),
728
				  argv[0], d->__nextchar);
729 730
#else
		  fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
731
			   argv[0], d->__nextchar);
732 733
#endif
		}
734
	      else
735 736 737 738
		{
		  /* +option or -option */
#if defined _LIBC && defined USE_IN_LIBIO
		  n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"),
739
				  argv[0], argv[d->optind][0], d->__nextchar);
740 741
#else
		  fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
742
			   argv[0], argv[d->optind][0], d->__nextchar);
743 744 745 746 747 748
#endif
		}

#if defined _LIBC && defined USE_IN_LIBIO
	      if (n >= 0)
		{
749 750 751 752 753
		  _IO_flockfile (stderr);

		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;

754 755 756 757 758
		  if (_IO_fwide (stderr, 0) > 0)
		    __fwprintf (stderr, L"%s", buf);
		  else
		    fputs (buf, stderr);

759 760 761
		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
		  _IO_funlockfile (stderr);

762 763 764
		  free (buf);
		}
#endif
765
	    }
766 767 768
	  d->__nextchar = (char *) "";
	  d->optind++;
	  d->optopt = 0;
769 770 771 772 773 774 775
	  return '?';
	}
    }

  /* Look at and handle the next short option-character.  */

  {
776 777
    char c = *d->__nextchar++;
    char *temp = strchr (optstring, c);
778 779

    /* Increment `optind' when we start to process its last character.  */
780 781
    if (*d->__nextchar == '\0')
      ++d->optind;
782 783 784

    if (temp == NULL || c == ':')
      {
785
	if (print_errors)
786
	  {
787 788 789 790 791
#if defined _LIBC && defined USE_IN_LIBIO
	      char *buf;
	      int n;
#endif

792
	    if (d->__posixly_correct)
793 794 795 796 797 798 799 800 801
	      {
		/* 1003.2 specifies the format of this message.  */
#if defined _LIBC && defined USE_IN_LIBIO
		n = __asprintf (&buf, _("%s: illegal option -- %c\n"),
				argv[0], c);
#else
		fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
#endif
	      }
802
	    else
803 804 805 806 807 808 809 810 811 812 813 814
	      {
#if defined _LIBC && defined USE_IN_LIBIO
		n = __asprintf (&buf, _("%s: invalid option -- %c\n"),
				argv[0], c);
#else
		fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
#endif
	      }

#if defined _LIBC && defined USE_IN_LIBIO
	    if (n >= 0)
	      {
815 816 817 818 819
		_IO_flockfile (stderr);

		int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
		((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;

820 821 822 823 824
		if (_IO_fwide (stderr, 0) > 0)
		  __fwprintf (stderr, L"%s", buf);
		else
		  fputs (buf, stderr);

825 826 827
		((_IO_FILE *) stderr)->_flags2 = old_flags2;
		_IO_funlockfile (stderr);

828 829 830
		free (buf);
	      }
#endif
831
	  }
832
	d->optopt = c;
833 834 835 836 837 838 839 840 841 842 843 844 845 846
	return '?';
      }
    /* Convenience. Treat POSIX -W foo same as long option --foo */
    if (temp[0] == 'W' && temp[1] == ';')
      {
	char *nameend;
	const struct option *p;
	const struct option *pfound = NULL;
	int exact = 0;
	int ambig = 0;
	int indfound = 0;
	int option_index;

	/* This is an option that requires an argument.  */
847
	if (*d->__nextchar != '\0')
848
	  {
849
	    d->optarg = d->__nextchar;
850 851
	    /* If we end this ARGV-element by taking the rest as an arg,
	       we must advance to the next element now.  */
852
	    d->optind++;
853
	  }
854
	else if (d->optind == argc)
855
	  {
856
	    if (print_errors)
857 858
	      {
		/* 1003.2 specifies the format of this message.  */
859 860 861 862 863 864 865
#if defined _LIBC && defined USE_IN_LIBIO
		char *buf;

		if (__asprintf (&buf,
				_("%s: option requires an argument -- %c\n"),
				argv[0], c) >= 0)
		  {
866 867 868 869 870
		    _IO_flockfile (stderr);

		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;

871 872 873 874 875
		    if (_IO_fwide (stderr, 0) > 0)
		      __fwprintf (stderr, L"%s", buf);
		    else
		      fputs (buf, stderr);

876 877 878
		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
		    _IO_funlockfile (stderr);

879 880 881
		    free (buf);
		  }
#else
882 883
		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
			 argv[0], c);
884
#endif
885
	      }
886
	    d->optopt = c;
887 888 889 890 891 892 893
	    if (optstring[0] == ':')
	      c = ':';
	    else
	      c = '?';
	    return c;
	  }
	else
894
	  /* We already incremented `d->optind' once;
895
	     increment it again when taking next ARGV-elt as argument.  */
896
	  d->optarg = argv[d->optind++];
897 898 899 900

	/* optarg is now the argument, see if it's in the
	   table of longopts.  */

901 902
	for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
	     nameend++)
903 904 905 906 907
	  /* Do nothing.  */ ;

	/* Test all long options for either exact match
	   or abbreviated matches.  */
	for (p = longopts, option_index = 0; p->name; p++, option_index++)
908
	  if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
909
	    {
910
	      if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
		{
		  /* Exact match found.  */
		  pfound = p;
		  indfound = option_index;
		  exact = 1;
		  break;
		}
	      else if (pfound == NULL)
		{
		  /* First nonexact match found.  */
		  pfound = p;
		  indfound = option_index;
		}
	      else
		/* Second or later nonexact match found.  */
		ambig = 1;
	    }
	if (ambig && !exact)
	  {
930 931 932 933 934 935
	    if (print_errors)
	      {
#if defined _LIBC && defined USE_IN_LIBIO
		char *buf;

		if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"),
936
				argv[0], argv[d->optind]) >= 0)
937
		  {
938 939 940 941 942
		    _IO_flockfile (stderr);

		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;

943 944 945 946 947
		    if (_IO_fwide (stderr, 0) > 0)
		      __fwprintf (stderr, L"%s", buf);
		    else
		      fputs (buf, stderr);

948 949 950
		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
		    _IO_funlockfile (stderr);

951 952 953 954
		    free (buf);
		  }
#else
		fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
955
			 argv[0], argv[d->optind]);
956 957
#endif
	      }
958 959
	    d->__nextchar += strlen (d->__nextchar);
	    d->optind++;
960 961 962 963 964 965 966 967 968 969
	    return '?';
	  }
	if (pfound != NULL)
	  {
	    option_index = indfound;
	    if (*nameend)
	      {
		/* Don't test has_arg with >, because some C compilers don't
		   allow it to be used on enums.  */
		if (pfound->has_arg)
970
		  d->optarg = nameend + 1;
971 972
		else
		  {
973 974 975 976 977 978 979 980 981
		    if (print_errors)
		      {
#if defined _LIBC && defined USE_IN_LIBIO
			char *buf;

			if (__asprintf (&buf, _("\
%s: option `-W %s' doesn't allow an argument\n"),
					argv[0], pfound->name) >= 0)
			  {
982 983 984 985 986 987
			    _IO_flockfile (stderr);

			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
			    ((_IO_FILE *) stderr)->_flags2
			      |= _IO_FLAGS2_NOTCANCEL;

988 989 990 991 992
			    if (_IO_fwide (stderr, 0) > 0)
			      __fwprintf (stderr, L"%s", buf);
			    else
			      fputs (buf, stderr);

993 994 995
			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
			    _IO_funlockfile (stderr);

996 997 998 999
			    free (buf);
			  }
#else
			fprintf (stderr, _("\
1000
%s: option `-W %s' doesn't allow an argument\n"),
1001 1002 1003
				 argv[0], pfound->name);
#endif
		      }
1004

1005
		    d->__nextchar += strlen (d->__nextchar);
1006 1007 1008 1009 1010
		    return '?';
		  }
	      }
	    else if (pfound->has_arg == 1)
	      {
1011 1012
		if (d->optind < argc)
		  d->optarg = argv[d->optind++];
1013 1014
		else
		  {
1015 1016 1017 1018 1019 1020 1021
		    if (print_errors)
		      {
#if defined _LIBC && defined USE_IN_LIBIO
			char *buf;

			if (__asprintf (&buf, _("\
%s: option `%s' requires an argument\n"),
1022
					argv[0], argv[d->optind - 1]) >= 0)
1023
			  {
1024 1025 1026 1027 1028 1029
			    _IO_flockfile (stderr);

			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
			    ((_IO_FILE *) stderr)->_flags2
			      |= _IO_FLAGS2_NOTCANCEL;

1030 1031 1032 1033 1034
			    if (_IO_fwide (stderr, 0) > 0)
			      __fwprintf (stderr, L"%s", buf);
			    else
			      fputs (buf, stderr);

1035 1036 1037
			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
			    _IO_funlockfile (stderr);

1038 1039 1040 1041 1042
			    free (buf);
			  }
#else
			fprintf (stderr,
				 _("%s: option `%s' requires an argument\n"),
1043
				 argv[0], argv[d->optind - 1]);
1044 1045
#endif
		      }
1046
		    d->__nextchar += strlen (d->__nextchar);
1047 1048 1049
		    return optstring[0] == ':' ? ':' : '?';
		  }
	      }
1050
	    d->__nextchar += strlen (d->__nextchar);
1051 1052 1053 1054 1055 1056 1057 1058 1059
	    if (longind != NULL)
	      *longind = option_index;
	    if (pfound->flag)
	      {
		*(pfound->flag) = pfound->val;
		return 0;
	      }
	    return pfound->val;
	  }
1060
	  d->__nextchar = NULL;
1061 1062 1063 1064 1065 1066 1067
	  return 'W';	/* Let the application handle it.   */
      }
    if (temp[1] == ':')
      {
	if (temp[2] == ':')
	  {
	    /* This is an option that accepts an argument optionally.  */
1068
	    if (*d->__nextchar != '\0')
1069
	      {
1070 1071
		d->optarg = d->__nextchar;
		d->optind++;
1072 1073
	      }
	    else
1074 1075
	      d->optarg = NULL;
	    d->__nextchar = NULL;
1076 1077 1078 1079
	  }
	else
	  {
	    /* This is an option that requires an argument.  */
1080
	    if (*d->__nextchar != '\0')
1081
	      {
1082
		d->optarg = d->__nextchar;
1083 1084
		/* If we end this ARGV-element by taking the rest as an arg,
		   we must advance to the next element now.  */
1085
		d->optind++;
1086
	      }
1087
	    else if (d->optind == argc)
1088
	      {
1089
		if (print_errors)
1090 1091
		  {
		    /* 1003.2 specifies the format of this message.  */
1092 1093 1094 1095 1096 1097 1098
#if defined _LIBC && defined USE_IN_LIBIO
		    char *buf;

		    if (__asprintf (&buf, _("\
%s: option requires an argument -- %c\n"),
				    argv[0], c) >= 0)
		      {
1099 1100 1101 1102 1103
			_IO_flockfile (stderr);

			int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
			((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;

1104 1105 1106 1107 1108
			if (_IO_fwide (stderr, 0) > 0)
			  __fwprintf (stderr, L"%s", buf);
			else
			  fputs (buf, stderr);

1109 1110 1111
			((_IO_FILE *) stderr)->_flags2 = old_flags2;
			_IO_funlockfile (stderr);

1112 1113 1114
			free (buf);
		      }
#else
1115
		    fprintf (stderr,
1116 1117 1118
			     _("%s: option requires an argument -- %c\n"),
			     argv[0], c);
#endif
1119
		  }
1120
		d->optopt = c;
1121 1122 1123 1124 1125 1126 1127 1128
		if (optstring[0] == ':')
		  c = ':';
		else
		  c = '?';
	      }
	    else
	      /* We already incremented `optind' once;
		 increment it again when taking next ARGV-elt as argument.  */
1129 1130
	      d->optarg = argv[d->optind++];
	    d->__nextchar = NULL;
1131 1132 1133 1134 1135 1136 1137
	  }
      }
    return c;
  }
}

int
1138 1139 1140
_getopt_internal (int argc, char **argv, const char *optstring,
		  const struct option *longopts, int *longind,
		  int long_only, int posixly_correct)
1141
{
1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
  int result;

  getopt_data.optind = optind;
  getopt_data.opterr = opterr;

  result = _getopt_internal_r (argc, argv, optstring, longopts, longind,
			       long_only, posixly_correct, &getopt_data);

  optind = getopt_data.optind;
  optarg = getopt_data.optarg;
  optopt = getopt_data.optopt;

  return result;
}

/* glibc gets a LSB-compliant getopt.
   Standalone applications get a POSIX-compliant getopt.  */
#if _LIBC
enum { POSIXLY_CORRECT = 0 };
#else
enum { POSIXLY_CORRECT = 1 };
#endif

int
getopt (int argc, char *const *argv, const char *optstring)
{
  return _getopt_internal (argc, (char **) argv, optstring, NULL, NULL, 0,
			   POSIXLY_CORRECT);
1170 1171 1172 1173 1174 1175 1176 1177 1178
}


#ifdef TEST

/* Compile with -DTEST to make an executable for use in testing
   the above definition of `getopt'.  */

int
1179
main (int argc, char **argv)
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
{
  int c;
  int digit_optind = 0;

  while (1)
    {
      int this_option_optind = optind ? optind : 1;

      c = getopt (argc, argv, "abc:d:0123456789");
      if (c == -1)
	break;

      switch (c)
	{
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  if (digit_optind != 0 && digit_optind != this_option_optind)
	    printf ("digits occur in two different argv-elements.\n");
	  digit_optind = this_option_optind;
	  printf ("option %c\n", c);
	  break;

	case 'a':
	  printf ("option a\n");
	  break;

	case 'b':
	  printf ("option b\n");
	  break;

	case 'c':
	  printf ("option c with value `%s'\n", optarg);
	  break;

	case '?':
	  break;

	default:
	  printf ("?? getopt returned character code 0%o ??\n", c);
	}
    }

  if (optind < argc)
    {
      printf ("non-option ARGV-elements: ");
      while (optind < argc)
	printf ("%s ", argv[optind++]);
      printf ("\n");
    }

  exit (0);
}

#endif /* TEST */