getopt.c 23.5 KB
Newer Older
Paul Eggert's avatar
Paul Eggert committed
1
/* Getopt for GNU.
Paul Eggert's avatar
Paul Eggert committed
2
   Copyright (C) 1987-2019 Free Software Foundation, Inc.
Paul Eggert's avatar
Paul Eggert committed
3 4
   This file is part of the GNU C Library and is also part of gnulib.
   Patches to this file should be submitted to both projects.
Paul Eggert's avatar
Paul Eggert committed
5

Paul Eggert's avatar
Paul Eggert committed
6 7 8 9
   The GNU C Library 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 3 of the License, or (at your option) any later version.
Paul Eggert's avatar
Paul Eggert committed
10

Paul Eggert's avatar
Paul Eggert committed
11
   The GNU C Library is distributed in the hope that it will be useful,
Paul Eggert's avatar
Paul Eggert committed
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
Paul Eggert's avatar
Paul Eggert committed
13 14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.
Paul Eggert's avatar
Paul Eggert committed
15

Paul Eggert's avatar
Paul Eggert committed
16 17
   You should have received a copy of the GNU General Public
   License along with the GNU C Library; if not, see
Paul Eggert's avatar
Paul Eggert committed
18
   <https://www.gnu.org/licenses/>.  */
Paul Eggert's avatar
Paul Eggert committed
19 20 21 22 23 24 25 26 27

#ifndef _LIBC
# include <config.h>
#endif

#include "getopt.h"

#include <stdio.h>
#include <stdlib.h>
Paul Eggert's avatar
Paul Eggert committed
28
#include <string.h>
Paul Eggert's avatar
Paul Eggert committed
29
#include <unistd.h>
Paul Eggert's avatar
Paul Eggert committed
30 31

#ifdef _LIBC
Paul Eggert's avatar
Paul Eggert committed
32 33 34 35 36 37 38
/* When used as part of glibc, error printing must be done differently
   for standards compliance.  getopt is not a cancellation point, so
   it must not call functions that are, and it is specified by an
   older standard than stdio locking, so it must not refer to
   functions in the "user namespace" related to stdio locking.
   Finally, it must use glibc's internal message translation so that
   the messages are looked up in the proper text domain.  */
Paul Eggert's avatar
Paul Eggert committed
39
# include <libintl.h>
Paul Eggert's avatar
Paul Eggert committed
40 41 42
# define fprintf __fxprintf_nocancel
# define flockfile(fp) _IO_flockfile (fp)
# define funlockfile(fp) _IO_funlockfile (fp)
Paul Eggert's avatar
Paul Eggert committed
43 44 45
#else
# include "gettext.h"
# define _(msgid) gettext (msgid)
Paul Eggert's avatar
Paul Eggert committed
46 47
/* When used standalone, flockfile and funlockfile might not be
   available.  */
Paul Eggert's avatar
Paul Eggert committed
48
# if (!defined _POSIX_THREAD_SAFE_FUNCTIONS \
Paul Eggert's avatar
Paul Eggert committed
49
      || (defined _WIN32 && ! defined __CYGWIN__))
Paul Eggert's avatar
Paul Eggert committed
50 51 52 53 54 55 56
#  define flockfile(fp) /* nop */
#  define funlockfile(fp) /* nop */
# endif
/* When used standalone, do not attempt to use alloca.  */
# define __libc_use_alloca(size) 0
# undef alloca
# define alloca(size) (abort (), (void *)0)
Paul Eggert's avatar
Paul Eggert committed
57 58
#endif

Paul Eggert's avatar
Paul Eggert committed
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
/* This implementation of 'getopt' has three modes for handling
   options interspersed with non-option arguments.  It can stop
   scanning for options at the first non-option argument encountered,
   as POSIX specifies.  It can continue scanning for options after the
   first non-option argument, but permute 'argv' as it goes so that,
   after 'getopt' is done, all the options precede all the non-option
   arguments and 'optind' points to the first non-option argument.
   Or, it can report non-option arguments as if they were arguments to
   the option character '\x01'.

   The default behavior of 'getopt_long' is to permute the argument list.
   When this implementation is used standalone, the default behavior of
   'getopt' is to stop at the first non-option argument, but when it is
   used as part of GNU libc it also permutes the argument list.  In both
   cases, setting the environment variable POSIXLY_CORRECT to any value
Paul Eggert's avatar
Paul Eggert committed
74 75
   disables permutation.

Paul Eggert's avatar
Paul Eggert committed
76 77 78 79
   If the first character of the OPTSTRING argument to 'getopt' or
   'getopt_long' is '+', both functions will stop at the first
   non-option argument.  If it is '-', both functions will report
   non-option arguments as arguments to the option character '\x01'.  */
Paul Eggert's avatar
Paul Eggert committed
80 81 82

#include "getopt_int.h"

Paul Eggert's avatar
Paul Eggert committed
83 84
/* For communication from 'getopt' to the caller.
   When 'getopt' finds an option that takes an argument,
Paul Eggert's avatar
Paul Eggert committed
85
   the argument value is returned here.
Paul Eggert's avatar
Paul Eggert committed
86
   Also, when 'ordering' is RETURN_IN_ORDER,
Paul Eggert's avatar
Paul Eggert committed
87 88 89 90 91 92
   each non-option ARGV-element is returned here.  */

char *optarg;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller
Paul Eggert's avatar
Paul Eggert committed
93
   and for communication between successive calls to 'getopt'.
Paul Eggert's avatar
Paul Eggert committed
94

Paul Eggert's avatar
Paul Eggert committed
95
   On entry to 'getopt', zero means this is the first call; initialize.
Paul Eggert's avatar
Paul Eggert committed
96

Paul Eggert's avatar
Paul Eggert committed
97
   When 'getopt' returns -1, this is the index of the first of the
Paul Eggert's avatar
Paul Eggert committed
98 99
   non-option elements that the caller should itself scan.

Paul Eggert's avatar
Paul Eggert committed
100
   Otherwise, 'optind' communicates from one call to the next
Paul Eggert's avatar
Paul Eggert committed
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
   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 = '?';

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

static struct _getopt_data getopt_data;

/* 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.

Paul Eggert's avatar
Paul Eggert committed
127
   'first_nonopt' and 'last_nonopt' are relocated so that they describe
Paul Eggert's avatar
Paul Eggert committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
   the new indices of the non-options in ARGV after they are moved.  */

static void
exchange (char **argv, struct _getopt_data *d)
{
  int bottom = d->__first_nonopt;
  int middle = d->__last_nonopt;
  int top = d->optind;
  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.  */

  while (top > middle && middle > bottom)
    {
      if (top - middle > middle - bottom)
Paul Eggert's avatar
Paul Eggert committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
	{
	  /* Bottom segment is the short one.  */
	  int len = middle - bottom;
	  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;
	    }
	  /* Exclude the moved bottom segment from further swapping.  */
	  top -= len;
	}
Paul Eggert's avatar
Paul Eggert committed
161
      else
Paul Eggert's avatar
Paul Eggert committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
	{
	  /* Top segment is the short one.  */
	  int len = top - middle;
	  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;
	    }
	  /* Exclude the moved top segment from further swapping.  */
	  bottom += len;
	}
Paul Eggert's avatar
Paul Eggert committed
177 178 179 180 181 182 183 184
    }

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

  d->__first_nonopt += (d->optind - d->__last_nonopt);
  d->__last_nonopt = d->optind;
}

Paul Eggert's avatar
Paul Eggert committed
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 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 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 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 366 367 368 369 370 371 372 373 374 375 376 377 378
/* Process the argument starting with d->__nextchar as a long option.
   d->optind should *not* have been advanced over this argument.

   If the value returned is -1, it was not actually a long option, the
   state is unchanged, and the argument should be processed as a set
   of short options (this can only happen when long_only is true).
   Otherwise, the option (and its argument, if any) have been consumed
   and the return value is the value to return from _getopt_internal_r.  */
static int
process_long_option (int argc, char **argv, const char *optstring,
		     const struct option *longopts, int *longind,
		     int long_only, struct _getopt_data *d,
		     int print_errors, const char *prefix)
{
  char *nameend;
  size_t namelen;
  const struct option *p;
  const struct option *pfound = NULL;
  int n_options;
  int option_index;

  for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
    /* Do nothing.  */ ;
  namelen = nameend - d->__nextchar;

  /* First look for an exact match, counting the options as a side
     effect.  */
  for (p = longopts, n_options = 0; p->name; p++, n_options++)
    if (!strncmp (p->name, d->__nextchar, namelen)
	&& namelen == strlen (p->name))
      {
	/* Exact match found.  */
	pfound = p;
	option_index = n_options;
	break;
      }

  if (pfound == NULL)
    {
      /* Didn't find an exact match, so look for abbreviations.  */
      unsigned char *ambig_set = NULL;
      int ambig_malloced = 0;
      int ambig_fallback = 0;
      int indfound = -1;

      for (p = longopts, option_index = 0; p->name; p++, option_index++)
	if (!strncmp (p->name, d->__nextchar, namelen))
	  {
	    if (pfound == NULL)
	      {
		/* First nonexact match found.  */
		pfound = p;
		indfound = option_index;
	      }
	    else if (long_only
		     || pfound->has_arg != p->has_arg
		     || pfound->flag != p->flag
		     || pfound->val != p->val)
	      {
		/* Second or later nonexact match found.  */
		if (!ambig_fallback)
		  {
		    if (!print_errors)
		      /* Don't waste effort tracking the ambig set if
			 we're not going to print it anyway.  */
		      ambig_fallback = 1;
		    else if (!ambig_set)
		      {
			if (__libc_use_alloca (n_options))
			  ambig_set = alloca (n_options);
			else if ((ambig_set = malloc (n_options)) == NULL)
			  /* Fall back to simpler error message.  */
			  ambig_fallback = 1;
			else
			  ambig_malloced = 1;

			if (ambig_set)
			  {
			    memset (ambig_set, 0, n_options);
			    ambig_set[indfound] = 1;
			  }
		      }
		    if (ambig_set)
		      ambig_set[option_index] = 1;
		  }
	      }
	  }

      if (ambig_set || ambig_fallback)
	{
	  if (print_errors)
	    {
	      if (ambig_fallback)
		fprintf (stderr, _("%s: option '%s%s' is ambiguous\n"),
			 argv[0], prefix, d->__nextchar);
	      else
		{
		  flockfile (stderr);
		  fprintf (stderr,
			   _("%s: option '%s%s' is ambiguous; possibilities:"),
			   argv[0], prefix, d->__nextchar);

		  for (option_index = 0; option_index < n_options; option_index++)
		    if (ambig_set[option_index])
		      fprintf (stderr, " '%s%s'",
			       prefix, longopts[option_index].name);

		  /* This must use 'fprintf' even though it's only
		     printing a single character, so that it goes through
		     __fxprintf_nocancel when compiled as part of glibc.  */
		  fprintf (stderr, "\n");
		  funlockfile (stderr);
		}
	    }
	  if (ambig_malloced)
	    free (ambig_set);
	  d->__nextchar += strlen (d->__nextchar);
	  d->optind++;
	  d->optopt = 0;
	  return '?';
	}

      option_index = indfound;
    }

  if (pfound == NULL)
    {
      /* 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.  */
      if (!long_only || argv[d->optind][1] == '-'
	  || strchr (optstring, *d->__nextchar) == NULL)
	{
	  if (print_errors)
	    fprintf (stderr, _("%s: unrecognized option '%s%s'\n"),
		     argv[0], prefix, d->__nextchar);

	  d->__nextchar = NULL;
	  d->optind++;
	  d->optopt = 0;
	  return '?';
	}

      /* Otherwise interpret it as a short option.  */
      return -1;
    }

  /* We have found a matching long option.  Consume it.  */
  d->optind++;
  d->__nextchar = NULL;
  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)
	d->optarg = nameend + 1;
      else
	{
	  if (print_errors)
	    fprintf (stderr,
		     _("%s: option '%s%s' doesn't allow an argument\n"),
		     argv[0], prefix, pfound->name);

	  d->optopt = pfound->val;
	  return '?';
	}
    }
  else if (pfound->has_arg == 1)
    {
      if (d->optind < argc)
	d->optarg = argv[d->optind++];
      else
	{
	  if (print_errors)
	    fprintf (stderr,
		     _("%s: option '%s%s' requires an argument\n"),
		     argv[0], prefix, pfound->name);

	  d->optopt = pfound->val;
	  return optstring[0] == ':' ? ':' : '?';
	}
    }

  if (longind != NULL)
    *longind = option_index;
  if (pfound->flag)
    {
      *(pfound->flag) = pfound->val;
      return 0;
    }
  return pfound->val;
}

/* Initialize internal data upon the first call to getopt.  */
Paul Eggert's avatar
Paul Eggert committed
379 380 381

static const char *
_getopt_initialize (int argc _GL_UNUSED,
Paul Eggert's avatar
Paul Eggert committed
382 383
		    char **argv _GL_UNUSED, const char *optstring,
		    struct _getopt_data *d, int posixly_correct)
Paul Eggert's avatar
Paul Eggert committed
384 385 386 387
{
  /* 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.  */
Paul Eggert's avatar
Paul Eggert committed
388 389
  if (d->optind == 0)
    d->optind = 1;
Paul Eggert's avatar
Paul Eggert committed
390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

  d->__first_nonopt = d->__last_nonopt = d->optind;
  d->__nextchar = NULL;

  /* Determine how to handle the ordering of options and nonoptions.  */
  if (optstring[0] == '-')
    {
      d->__ordering = RETURN_IN_ORDER;
      ++optstring;
    }
  else if (optstring[0] == '+')
    {
      d->__ordering = REQUIRE_ORDER;
      ++optstring;
    }
Paul Eggert's avatar
Paul Eggert committed
405
  else if (posixly_correct || !!getenv ("POSIXLY_CORRECT"))
Paul Eggert's avatar
Paul Eggert committed
406 407 408 409
    d->__ordering = REQUIRE_ORDER;
  else
    d->__ordering = PERMUTE;

Paul Eggert's avatar
Paul Eggert committed
410
  d->__initialized = 1;
Paul Eggert's avatar
Paul Eggert committed
411 412 413 414 415 416 417 418
  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
Paul Eggert's avatar
Paul Eggert committed
419
   (aside from the initial '-') are option characters.  If 'getopt'
Paul Eggert's avatar
Paul Eggert committed
420 421 422
   is called repeatedly, it returns successively each of the option characters
   from each of the option elements.

Paul Eggert's avatar
Paul Eggert committed
423 424
   If 'getopt' finds another option character, it returns that character,
   updating 'optind' and 'nextchar' so that the next call to 'getopt' can
Paul Eggert's avatar
Paul Eggert committed
425 426
   resume the scan with the following option character or ARGV-element.

Paul Eggert's avatar
Paul Eggert committed
427 428
   If there are no more option characters, 'getopt' returns -1.
   Then 'optind' is the index in ARGV of the first ARGV-element
Paul Eggert's avatar
Paul Eggert committed
429 430 431 432 433
   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,
Paul Eggert's avatar
Paul Eggert committed
434
   return '?' after printing an error message.  If you set 'opterr' to
Paul Eggert's avatar
Paul Eggert committed
435 436 437 438
   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
Paul Eggert's avatar
Paul Eggert committed
439
   ARGV-element, is returned in 'optarg'.  Two colons mean an option that
Paul Eggert's avatar
Paul Eggert committed
440
   wants an optional arg; if there is text in the current ARGV-element,
Paul Eggert's avatar
Paul Eggert committed
441
   it is returned in 'optarg', otherwise 'optarg' is set to zero.
Paul Eggert's avatar
Paul Eggert committed
442

Paul Eggert's avatar
Paul Eggert committed
443
   If OPTSTRING starts with '-' or '+', it requests different methods of
Paul Eggert's avatar
Paul Eggert committed
444 445 446
   handling the non-option ARGV-elements.
   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.

Paul Eggert's avatar
Paul Eggert committed
447
   Long-named options begin with '--' instead of '-'.
Paul Eggert's avatar
Paul Eggert committed
448 449 450
   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
Paul Eggert's avatar
Paul Eggert committed
451 452 453 454
   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.
Paul Eggert's avatar
Paul Eggert committed
455 456 457 458 459

   The elements of ARGV aren't really const, because we permute them.
   But we pretend they're const in the prototype to be compatible
   with other systems.

Paul Eggert's avatar
Paul Eggert committed
460
   LONGOPTS is a vector of 'struct option' terminated by an
Paul Eggert's avatar
Paul Eggert committed
461 462 463 464 465 466 467 468 469 470 471
   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
   long-named options.  */

int
_getopt_internal_r (int argc, char **argv, const char *optstring,
Paul Eggert's avatar
Paul Eggert committed
472 473
		    const struct option *longopts, int *longind,
		    int long_only, struct _getopt_data *d, int posixly_correct)
Paul Eggert's avatar
Paul Eggert committed
474 475 476 477 478 479 480 481 482
{
  int print_errors = d->opterr;

  if (argc < 1)
    return -1;

  d->optarg = NULL;

  if (d->optind == 0 || !d->__initialized)
Paul Eggert's avatar
Paul Eggert committed
483
    optstring = _getopt_initialize (argc, argv, optstring, d, posixly_correct);
Paul Eggert's avatar
Paul Eggert committed
484 485
  else if (optstring[0] == '-' || optstring[0] == '+')
    optstring++;
Paul Eggert's avatar
Paul Eggert committed
486

Paul Eggert's avatar
Paul Eggert committed
487 488 489
  if (optstring[0] == ':')
    print_errors = 0;

Paul Eggert's avatar
Paul Eggert committed
490 491
  /* Test whether ARGV[optind] points to a non-option argument.  */
#define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
Paul Eggert's avatar
Paul Eggert committed
492 493 494 495 496 497

  if (d->__nextchar == NULL || *d->__nextchar == '\0')
    {
      /* Advance to the next ARGV-element.  */

      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
Paul Eggert's avatar
Paul Eggert committed
498
	 moved back by the user (who may also have changed the arguments).  */
Paul Eggert's avatar
Paul Eggert committed
499
      if (d->__last_nonopt > d->optind)
Paul Eggert's avatar
Paul Eggert committed
500
	d->__last_nonopt = d->optind;
Paul Eggert's avatar
Paul Eggert committed
501
      if (d->__first_nonopt > d->optind)
Paul Eggert's avatar
Paul Eggert committed
502
	d->__first_nonopt = d->optind;
Paul Eggert's avatar
Paul Eggert committed
503 504

      if (d->__ordering == PERMUTE)
Paul Eggert's avatar
Paul Eggert committed
505 506 507
	{
	  /* If we have just processed some options following some non-options,
	     exchange them so that the options come first.  */
Paul Eggert's avatar
Paul Eggert committed
508

Paul Eggert's avatar
Paul Eggert committed
509 510 511 512 513
	  if (d->__first_nonopt != d->__last_nonopt
	      && d->__last_nonopt != d->optind)
	    exchange (argv, d);
	  else if (d->__last_nonopt != d->optind)
	    d->__first_nonopt = d->optind;
Paul Eggert's avatar
Paul Eggert committed
514

Paul Eggert's avatar
Paul Eggert committed
515 516
	  /* Skip any additional non-options
	     and extend the range of non-options previously skipped.  */
Paul Eggert's avatar
Paul Eggert committed
517

Paul Eggert's avatar
Paul Eggert committed
518 519 520 521
	  while (d->optind < argc && NONOPTION_P)
	    d->optind++;
	  d->__last_nonopt = d->optind;
	}
Paul Eggert's avatar
Paul Eggert committed
522

Paul Eggert's avatar
Paul Eggert committed
523
      /* The special ARGV-element '--' means premature end of options.
Paul Eggert's avatar
Paul Eggert committed
524 525 526
	 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.  */
Paul Eggert's avatar
Paul Eggert committed
527 528

      if (d->optind != argc && !strcmp (argv[d->optind], "--"))
Paul Eggert's avatar
Paul Eggert committed
529 530
	{
	  d->optind++;
Paul Eggert's avatar
Paul Eggert committed
531

Paul Eggert's avatar
Paul Eggert committed
532 533 534 535 536 537
	  if (d->__first_nonopt != d->__last_nonopt
	      && d->__last_nonopt != d->optind)
	    exchange (argv, d);
	  else if (d->__first_nonopt == d->__last_nonopt)
	    d->__first_nonopt = d->optind;
	  d->__last_nonopt = argc;
Paul Eggert's avatar
Paul Eggert committed
538

Paul Eggert's avatar
Paul Eggert committed
539 540
	  d->optind = argc;
	}
Paul Eggert's avatar
Paul Eggert committed
541 542

      /* If we have done all the ARGV-elements, stop the scan
Paul Eggert's avatar
Paul Eggert committed
543
	 and back over any non-options that we skipped and permuted.  */
Paul Eggert's avatar
Paul Eggert committed
544 545

      if (d->optind == argc)
Paul Eggert's avatar
Paul Eggert committed
546 547 548 549 550 551 552
	{
	  /* Set the next-arg-index to point at the non-options
	     that we previously skipped, so the caller will digest them.  */
	  if (d->__first_nonopt != d->__last_nonopt)
	    d->optind = d->__first_nonopt;
	  return -1;
	}
Paul Eggert's avatar
Paul Eggert committed
553 554

      /* If we have come to a non-option and did not permute it,
Paul Eggert's avatar
Paul Eggert committed
555
	 either stop the scan or describe it to the caller and pass it by.  */
Paul Eggert's avatar
Paul Eggert committed
556 557

      if (NONOPTION_P)
Paul Eggert's avatar
Paul Eggert committed
558 559 560 561 562 563
	{
	  if (d->__ordering == REQUIRE_ORDER)
	    return -1;
	  d->optarg = argv[d->optind++];
	  return 1;
	}
Paul Eggert's avatar
Paul Eggert committed
564 565

      /* We have found another option-ARGV-element.
Paul Eggert's avatar
Paul Eggert committed
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
	 Check whether it might be a long option.  */
      if (longopts)
	{
	  if (argv[d->optind][1] == '-')
	    {
	      /* "--foo" is always a long option.  The special option
		 "--" was handled above.  */
	      d->__nextchar = argv[d->optind] + 2;
	      return process_long_option (argc, argv, optstring, longopts,
					  longind, long_only, d,
					  print_errors, "--");
	    }

	  /* 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 (long_only && (argv[d->optind][2]
			    || !strchr (optstring, argv[d->optind][1])))
	    {
	      int code;
	      d->__nextchar = argv[d->optind] + 1;
	      code = process_long_option (argc, argv, optstring, longopts,
					  longind, long_only, d,
					  print_errors, "-");
	      if (code != -1)
		return code;
	    }
	}

      /* It is not a long option.  Skip the initial punctuation.  */
      d->__nextchar = argv[d->optind] + 1;
Paul Eggert's avatar
Paul Eggert committed
606 607 608 609 610 611 612 613
    }

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

  {
    char c = *d->__nextchar++;
    const char *temp = strchr (optstring, c);

Paul Eggert's avatar
Paul Eggert committed
614
    /* Increment 'optind' when we start to process its last character.  */
Paul Eggert's avatar
Paul Eggert committed
615 616 617 618 619
    if (*d->__nextchar == '\0')
      ++d->optind;

    if (temp == NULL || c == ':' || c == ';')
      {
Paul Eggert's avatar
Paul Eggert committed
620 621 622 623
	if (print_errors)
	  fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
	d->optopt = c;
	return '?';
Paul Eggert's avatar
Paul Eggert committed
624
      }
Paul Eggert's avatar
Paul Eggert committed
625

Paul Eggert's avatar
Paul Eggert committed
626
    /* Convenience. Treat POSIX -W foo same as long option --foo */
Paul Eggert's avatar
Paul Eggert committed
627
    if (temp[0] == 'W' && temp[1] == ';' && longopts != NULL)
Paul Eggert's avatar
Paul Eggert committed
628
      {
Paul Eggert's avatar
Paul Eggert committed
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
	/* This is an option that requires an argument.  */
	if (*d->__nextchar != '\0')
	  d->optarg = d->__nextchar;
	else if (d->optind == argc)
	  {
	    if (print_errors)
	      fprintf (stderr,
		       _("%s: option requires an argument -- '%c'\n"),
		       argv[0], c);

	    d->optopt = c;
	    if (optstring[0] == ':')
	      c = ':';
	    else
	      c = '?';
	    return c;
	  }
	else
	  d->optarg = argv[d->optind];

	d->__nextchar = d->optarg;
	d->optarg = NULL;
	return process_long_option (argc, argv, optstring, longopts, longind,
				    0 /* long_only */, d, print_errors, "-W ");
Paul Eggert's avatar
Paul Eggert committed
653 654 655
      }
    if (temp[1] == ':')
      {
Paul Eggert's avatar
Paul Eggert committed
656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
	if (temp[2] == ':')
	  {
	    /* This is an option that accepts an argument optionally.  */
	    if (*d->__nextchar != '\0')
	      {
		d->optarg = d->__nextchar;
		d->optind++;
	      }
	    else
	      d->optarg = NULL;
	    d->__nextchar = NULL;
	  }
	else
	  {
	    /* This is an option that requires an argument.  */
	    if (*d->__nextchar != '\0')
	      {
		d->optarg = d->__nextchar;
		/* If we end this ARGV-element by taking the rest as an arg,
		   we must advance to the next element now.  */
		d->optind++;
	      }
	    else if (d->optind == argc)
	      {
		if (print_errors)
		  fprintf (stderr,
			   _("%s: option requires an argument -- '%c'\n"),
			   argv[0], c);

		d->optopt = c;
		if (optstring[0] == ':')
		  c = ':';
		else
		  c = '?';
	      }
	    else
	      /* We already incremented 'optind' once;
		 increment it again when taking next ARGV-elt as argument.  */
	      d->optarg = argv[d->optind++];
	    d->__nextchar = NULL;
	  }
Paul Eggert's avatar
Paul Eggert committed
697 698 699 700 701 702 703
      }
    return c;
  }
}

int
_getopt_internal (int argc, char **argv, const char *optstring,
Paul Eggert's avatar
Paul Eggert committed
704 705
		  const struct option *longopts, int *longind, int long_only,
		  int posixly_correct)
Paul Eggert's avatar
Paul Eggert committed
706 707 708 709 710 711 712
{
  int result;

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

  result = _getopt_internal_r (argc, argv, optstring, longopts,
Paul Eggert's avatar
Paul Eggert committed
713 714
			       longind, long_only, &getopt_data,
			       posixly_correct);
Paul Eggert's avatar
Paul Eggert committed
715 716 717 718 719 720 721 722

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

  return result;
}

Paul Eggert's avatar
Paul Eggert committed
723 724 725 726 727 728 729 730 731 732 733
/* glibc gets a LSB-compliant getopt and a POSIX-complaint __posix_getopt.
   Standalone applications just get a POSIX-compliant getopt.
   POSIX and LSB both require these functions to take 'char *const *argv'
   even though this is incorrect (because of the permutation).  */
#define GETOPT_ENTRY(NAME, POSIXLY_CORRECT)			\
  int								\
  NAME (int argc, char *const *argv, const char *optstring)	\
  {								\
    return _getopt_internal (argc, (char **)argv, optstring,	\
			     0, 0, 0, POSIXLY_CORRECT);		\
  }
Paul Eggert's avatar
Paul Eggert committed
734 735

#ifdef _LIBC
Paul Eggert's avatar
Paul Eggert committed
736 737 738 739
GETOPT_ENTRY(getopt, 0)
GETOPT_ENTRY(__posix_getopt, 1)
#else
GETOPT_ENTRY(getopt, 1)
Paul Eggert's avatar
Paul Eggert committed
740 741 742 743 744 745
#endif


#ifdef TEST

/* Compile with -DTEST to make an executable for use in testing
Paul Eggert's avatar
Paul Eggert committed
746
   the above definition of 'getopt'.  */
Paul Eggert's avatar
Paul Eggert committed
747 748 749 750 751 752 753 754 755 756 757 758 759

int
main (int argc, char **argv)
{
  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)
Paul Eggert's avatar
Paul Eggert committed
760
	break;
Paul Eggert's avatar
Paul Eggert committed
761 762

      switch (c)
Paul Eggert's avatar
Paul Eggert committed
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	{
	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);
	}
Paul Eggert's avatar
Paul Eggert committed
798 799 800 801 802 803
    }

  if (optind < argc)
    {
      printf ("non-option ARGV-elements: ");
      while (optind < argc)
Paul Eggert's avatar
Paul Eggert committed
804
	printf ("%s ", argv[optind++]);
Paul Eggert's avatar
Paul Eggert committed
805 806 807 808 809 810 811
      printf ("\n");
    }

  exit (0);
}

#endif /* TEST */