annotate src/getopt.c @ 2951:b74f4f7165a1

[gaim-migrate @ 2964] Here, Yahoo should work again. Thanks for the quick fix, Sean. We should probably change some things in a bit. I'm tired of people complaining ;-) committer: Tailor Script <[e-mail]>

�     1 /* Getopt for GNU.
�     2    NOTE: getopt is now part of the C library, so if you don't know what
�     3    "Keep this file name-space clean" means, talk to [e-mail]
�     4    before changing it!
�     5 
�     6    Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
�     7    	Free Software Foundation, Inc.
�     8 
�     9    This program is free software; you can redistribute it and/or modify it
�    10    under the terms of the GNU General Public License as published by the
�    11    Free Software Foundation; either version 2, or (at your option) any
�    12    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, write to the Free Software
�    21    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
�    22 
�    23 /* NOTE!!!  AIX requires this to be the first thing in the file.
�    24    Do not put ANYTHING before it!  */
�    25 #if !defined (__GNUC__) && defined (_AIX)
�    26  #pragma alloca
�    27 #endif
�    28 
�    29 #ifdef HAVE_CONFIG_H
�    30 #include "config.h"
�    31 #endif
�    32 
�    33 #ifdef __GNUC__
�    34 #define alloca __builtin_alloca
�    35 #else /* not __GNUC__ */
�    36 #if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__))))
�    37 #include <alloca.h>
�    38 #else
�    39 #ifndef _AIX
�    40 char *alloca ();
�    41 #endif
�    42 #endif /* alloca.h */
�    43 #endif /* not __GNUC__ */
�    44 
�    45 #if !__STDC__ && !defined(const) && IN_GCC
�    46 #define const
�    47 #endif
�    48 
�    49 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.  */
�    50 #ifndef _NO_PROTO
�    51 #define _NO_PROTO
�    52 #endif
�    53 
�    54 #include <stdio.h>
�    55 
�    56 /* Comment out all this code if we are using the GNU C Library, and are not
�    57    actually compiling the library itself.  This code is part of the GNU C
�    58    Library, but also included in many other GNU distributions.  Compiling
�    59    and linking in this code is a waste when using the GNU C library
�    60    (especially if it is a shared library).  Rather than having every GNU
�    61    program understand `configure --with-gnu-libc' and omit the object files,
�    62    it is simpler to just do this in the source for each such file.  */
�    63 
�    64 #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
�    65 
�    66 
�    67 /* This needs to come after some library #include
�    68    to get __GNU_LIBRARY__ defined.  */
�    69 #ifdef	__GNU_LIBRARY__
�    70 #undef	alloca
�    71 /* Don't include stdlib.h for non-GNU C libraries because some of them
�    72    contain conflicting prototypes for getopt.  */
�    73 #include <stdlib.h>
�    74 #else	/* Not GNU C library.  */
�    75 #define	__alloca	alloca
�    76 #endif	/* GNU C library.  */
�    77 
�    78 /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
�    79    long-named option.  Because this is not POSIX.2 compliant, it is
�    80    being phased out.  */
�    81 /* #define GETOPT_COMPAT */
�    82 
�    83 /* This version of `getopt' appears to the caller like standard Unix `getopt'
�    84    but it behaves differently for the user, since it allows the user
�    85    to intersperse the options with the other arguments.
�    86 
�    87    As `getopt' works, it permutes the elements of ARGV so that,
�    88    when it is done, all the options precede everything else.  Thus
�    89    all application programs are extended to handle flexible argument order.
�    90 
�    91    Setting the environment variable POSIXLY_CORRECT disables permutation.
�    92    Then the behavior is completely standard.
�    93 
�    94    GNU application programs can use a third alternative mode in which
�    95    they can distinguish the relative order of options and other arguments.  */
�    96 
�    97 #include "getopt.h"
�    98 
�    99 /* For communication from `getopt' to the caller.
�   100    When `getopt' finds an option that takes an argument,
�   101    the argument value is returned here.
�   102    Also, when `ordering' is RETURN_IN_ORDER,
�   103    each non-option ARGV-element is returned here.  */
�   104 
�   105 char *optarg = 0;
�   106 
�   107 /* Index in ARGV of the next element to be scanned.
�   108    This is used for communication to and from the caller
�   109    and for communication between successive calls to `getopt'.
�   110 
�   111    On entry to `getopt', zero means this is the first call; initialize.
�   112 
�   113    When `getopt' returns EOF, this is the index of the first of the
�   114    non-option elements that the caller should itself scan.
�   115 
�   116    Otherwise, `optind' communicates from one call to the next
�   117    how much of ARGV has been scanned so far.  */
�   118 
�   119 /* XXX 1003.2 says this must be 1 before any call.  */
�   120 int optind = 0;
�   121 
�   122 /* The next char to be scanned in the option-element
�   123    in which the last option character we returned was found.
�   124    This allows us to pick up the scan where we left off.
�   125 
�   126    If this is zero, or a null string, it means resume the scan
�   127    by advancing to the next ARGV-element.  */
�   128 
�   129 static char *nextchar;
�   130 
�   131 /* Callers store zero here to inhibit the error message
�   132    for unrecognized options.  */
�   133 
�   134 int opterr = 1;
�   135 
�   136 /* Set to an option character which was unrecognized.
�   137    This must be initialized on some systems to avoid linking in the
�   138    system's own getopt implementation.  */
�   139 
�   140 int optopt = '?';
�   141 
�   142 /* Describe how to deal with options that follow non-option ARGV-elements.
�   143 
�   144    If the caller did not specify anything,
�   145    the default is REQUIRE_ORDER if the environment variable
�   146    POSIXLY_CORRECT is defined, PERMUTE otherwise.
�   147 
�   148    REQUIRE_ORDER means don't recognize them as options;
�   149    stop option processing when the first non-option is seen.
�   150    This is what Unix does.
�   151    This mode of operation is selected by either setting the environment
�   152    variable POSIXLY_CORRECT, or using `+' as the first character
�   153    of the list of option characters.
�   154 
�   155    PERMUTE is the default.  We permute the contents of ARGV as we scan,
�   156    so that eventually all the non-options are at the end.  This allows options
�   157    to be given in any order, even with programs that were not written to
�   158    expect this.
�   159 
�   160    RETURN_IN_ORDER is an option available to programs that were written
�   161    to expect options and other ARGV-elements in any order and that care about
�   162    the ordering of the two.  We describe each non-option ARGV-element
�   163    as if it were the argument of an option with character code 1.
�   164    Using `-' as the first character of the list of option characters
�   165    selects this mode of operation.
�   166 
�   167    The special argument `--' forces an end of option-scanning regardless
�   168    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
�   169    `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
�   170 
�   171 static enum
�   172 {
�   173   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
�   174 } ordering;
�   175 
�   176 #ifdef	__GNU_LIBRARY__
�   177 /* We want to avoid inclusion of string.h with non-GNU libraries
�   178    because there are many ways it can cause trouble.
�   179    On some systems, it contains special magic macros that don't work
�   180    in GCC.  */
�   181 #include <string.h>
�   182 #define	my_index	strchr
�   183 #define	my_bcopy(src, dst, n)	memcpy ((dst), (src), (n))
�   184 #else
�   185 
�   186 /* Avoid depending on library functions or files
�   187    whose names are inconsistent.  */
�   188 
�   189 char *getenv ();
�   190 
�   191 static char *
�   192 my_index (str, chr)
�   193      const char *str;
�   194      int chr;
�   195 {
�   196   while (*str)
�   197     {
�   198       if (*str == chr)
�   199 	return (char *) str;
�   200       str++;
�   201     }
�   202   return 0;
�   203 }
�   204 
�   205 static void
�   206 my_bcopy (from, to, size)
�   207      const char *from;
�   208      char *to;
�   209      int size;
�   210 {
�   211   int i;
�   212   for (i = 0; i < size; i++)
�   213     to[i] = from[i];
�   214 }
�   215 #endif				/* GNU C library.  */
�   216 
�   217 /* Handle permutation of arguments.  */
�   218 
�   219 /* Describe the part of ARGV that contains non-options that have
�   220    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
�   221    `last_nonopt' is the index after the last of them.  */
�   222 
�   223 static int first_nonopt;
�   224 static int last_nonopt;
�   225 
�   226 /* Exchange two adjacent subsequences of ARGV.
�   227    One subsequence is elements [first_nonopt,last_nonopt)
�   228    which contains all the non-options that have been skipped so far.
�   229    The other is elements [last_nonopt,optind), which contains all
�   230    the options processed since those non-options were skipped.
�   231 
�   232    `first_nonopt' and `last_nonopt' are relocated so that they describe
�   233    the new indices of the non-options in ARGV after they are moved.  */
�   234 
�   235 static void
�   236 exchange (argv)
�   237      char **argv;
�   238 {
�   239   int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
�   240   char **temp = (char **) __alloca (nonopts_size);
�   241 
�   242   /* Interchange the two blocks of data in ARGV.  */
�   243 
�   244   my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size);
�   245   my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt],
�   246 	    (optind - last_nonopt) * sizeof (char *));
�   247   my_bcopy ((char *) temp,
�   248 	    (char *) &argv[first_nonopt + optind - last_nonopt],
�   249 	    nonopts_size);
�   250 
�   251   /* Update records for the slots the non-options now occupy.  */
�   252 
�   253   first_nonopt += (optind - last_nonopt);
�   254   last_nonopt = optind;
�   255 }
�   256 
�   257 /* Scan elements of ARGV (whose length is ARGC) for option characters
�   258    given in OPTSTRING.
�   259 
�   260    If an element of ARGV starts with '-', and is not exactly "-" or "--",
�   261    then it is an option element.  The characters of this element
�   262    (aside from the initial '-') are option characters.  If `getopt'
�   263    is called repeatedly, it returns successively each of the option characters
�   264    from each of the option elements.
�   265 
�   266    If `getopt' finds another option character, it returns that character,
�   267    updating `optind' and `nextchar' so that the next call to `getopt' can
�   268    resume the scan with the following option character or ARGV-element.
�   269 
�   270    If there are no more option characters, `getopt' returns `EOF'.
�   271    Then `optind' is the index in ARGV of the first ARGV-element
�   272    that is not an option.  (The ARGV-elements have been permuted
�   273    so that those that are not options now come last.)
�   274 
�   275    OPTSTRING is a string containing the legitimate option characters.
�   276    If an option character is seen that is not listed in OPTSTRING,
�   277    return '?' after printing an error message.  If you set `opterr' to
�   278    zero, the error message is suppressed but we still return '?'.
�   279 
�   280    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
�   281    so the following text in the same ARGV-element, or the text of the following
�   282    ARGV-element, is returned in `optarg'.  Two colons mean an option that
�   283    wants an optional arg; if there is text in the current ARGV-element,
�   284    it is returned in `optarg', otherwise `optarg' is set to zero.
�   285 
�   286    If OPTSTRING starts with `-' or `+', it requests different methods of
�   287    handling the non-option ARGV-elements.
�   288    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
�   289 
�   290    Long-named options begin with `--' instead of `-'.
�   291    Their names may be abbreviated as long as the abbreviation is unique
�   292    or is an exact match for some defined option.  If they have an
�   293    argument, it follows the option name in the same ARGV-element, separated
�   294    from the option name by a `=', or else the in next ARGV-element.
�   295    When `getopt' finds a long-named option, it returns 0 if that option's
�   296    `flag' field is nonzero, the value of the option's `val' field
�   297    if the `flag' field is zero.
�   298 
�   299    The elements of ARGV aren't really const, because we permute them.
�   300    But we pretend they're const in the prototype to be compatible
�   301    with other systems.
�   302 
�   303    LONGOPTS is a vector of `struct option' terminated by an
�   304    element containing a name which is zero.
�   305 
�   306    LONGIND returns the index in LONGOPT of the long-named option found.
�   307    It is only valid when a long-named option has been found by the most
�   308    recent call.
�   309 
�   310    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
�   311    long-named options.  */
�   312 
�   313 int
�   314 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
�   315      int argc;
�   316      char *const *argv;
�   317      const char *optstring;
�   318      const struct option *longopts;
�   319      int *longind;
�   320      int long_only;
�   321 {
�   322   int option_index;
�   323 
�   324   optarg = 0;
�   325 
�   326   /* Initialize the internal data when the first call is made.
�   327      Start processing options with ARGV-element 1 (since ARGV-element 0
�   328      is the program name); the sequence of previously skipped
�   329      non-option ARGV-elements is empty.  */
�   330 
�   331   if (optind == 0)
�   332     {
�   333       first_nonopt = last_nonopt = optind = 1;
�   334 
�   335       nextchar = NULL;
�   336 
�   337       /* Determine how to handle the ordering of options and nonoptions.  */
�   338 
�   339       if (optstring[0] == '-')
�   340 	{
�   341 	  ordering = RETURN_IN_ORDER;
�   342 	  ++optstring;
�   343 	}
�   344       else if (optstring[0] == '+')
�   345 	{
�   346 	  ordering = REQUIRE_ORDER;
�   347 	  ++optstring;
�   348 	}
�   349       else if (getenv ("POSIXLY_CORRECT") != NULL)
�   350 	ordering = REQUIRE_ORDER;
�   351       else
�   352 	ordering = PERMUTE;
�   353     }
�   354 
�   355   if (nextchar == NULL || *nextchar == '\0')
�   356     {
�   357       if (ordering == PERMUTE)
�   358 	{
�   359 	  /* If we have just processed some options following some non-options,
�   360 	     exchange them so that the options come first.  */
�   361 
�   362 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
�   363 	    exchange ((char **) argv);
�   364 	  else if (last_nonopt != optind)
�   365 	    first_nonopt = optind;
�   366 
�   367 	  /* Now skip any additional non-options
�   368 	     and extend the range of non-options previously skipped.  */
�   369 
�   370 	  while (optind < argc
�   371 		 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
�   372 #ifdef GETOPT_COMPAT
�   373 		 && (longopts == NULL
�   374 		     || argv[optind][0] != '+' || argv[optind][1] == '\0')
�   375 #endif				/* GETOPT_COMPAT */
�   376 		 )
�   377 	    optind++;
�   378 	  last_nonopt = optind;
�   379 	}
�   380 
�   381       /* Special ARGV-element `--' means premature end of options.
�   382 	 Skip it like a null option,
�   383 	 then exchange with previous non-options as if it were an option,
�   384 	 then skip everything else like a non-option.  */
�   385 
�   386       if (optind != argc && !strcmp (argv[optind], "--"))
�   387 	{
�   388 	  optind++;
�   389 
�   390 	  if (first_nonopt != last_nonopt && last_nonopt != optind)
�   391 	    exchange ((char **) argv);
�   392 	  else if (first_nonopt == last_nonopt)
�   393 	    first_nonopt = optind;
�   394 	  last_nonopt = argc;
�   395 
�   396 	  optind = argc;
�   397 	}
�   398 
�   399       /* If we have done all the ARGV-elements, stop the scan
�   400 	 and back over any non-options that we skipped and permuted.  */
�   401 
�   402       if (optind == argc)
�   403 	{
�   404 	  /* Set the next-arg-index to point at the non-options
�   405 	     that we previously skipped, so the caller will digest them.  */
�   406 	  if (first_nonopt != last_nonopt)
�   407 	    optind = first_nonopt;
�   408 	  return EOF;
�   409 	}
�   410 
�   411       /* If we have come to a non-option and did not permute it,
�   412 	 either stop the scan or describe it to the caller and pass it by.  */
�   413 
�   414       if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
�   415 #ifdef GETOPT_COMPAT
�   416 	  && (longopts == NULL
�   417 	      || argv[optind][0] != '+' || argv[optind][1] == '\0')
�   418 #endif				/* GETOPT_COMPAT */
�   419 	  )
�   420 	{
�   421 	  if (ordering == REQUIRE_ORDER)
�   422 	    return EOF;
�   423 	  optarg = argv[optind++];
�   424 	  return 1;
�   425 	}
�   426 
�   427       /* We have found another option-ARGV-element.
�   428 	 Start decoding its characters.  */
�   429 
�   430       nextchar = (argv[optind] + 1
�   431 		  + (longopts != NULL && argv[optind][1] == '-'));
�   432     }
�   433 
�   434   if (longopts != NULL
�   435       && ((argv[optind][0] == '-'
�   436 	   && (argv[optind][1] == '-' || long_only))
�   437 #ifdef GETOPT_COMPAT
�   438 	  || argv[optind][0] == '+'
�   439 #endif				/* GETOPT_COMPAT */
�   440 	  ))
�   441     {
�   442       const struct option *p;
�   443       char *s = nextchar;
�   444       int exact = 0;
�   445       int ambig = 0;
�   446       const struct option *pfound = NULL;
�   447       int indfound;
�   448 
�   449       while (*s && *s != '=')
�   450 	s++;
�   451 
�   452       /* Test all options for either exact match or abbreviated matches.  */
�   453       for (p = longopts, option_index = 0; p->name;
�   454 	   p++, option_index++)
�   455 	if (!strncmp (p->name, nextchar, s - nextchar))
�   456 	  {
�   457 	    if (s - nextchar == strlen (p->name))
�   458 	      {
�   459 		/* Exact match found.  */
�   460 		pfound = p;
�   461 		indfound = option_index;
�   462 		exact = 1;
�   463 		break;
�   464 	      }
�   465 	    else if (pfound == NULL)
�   466 	      {
�   467 		/* First nonexact match found.  */
�   468 		pfound = p;
�   469 		indfound = option_index;
�   470 	      }
�   471 	    else
�   472 	      /* Second nonexact match found.  */
�   473 	      ambig = 1;
�   474 	  }
�   475 
�   476       if (ambig && !exact)
�   477 	{
�   478 	  if (opterr)
�   479 	    fprintf (stderr, "%s: option `%s' is ambiguous\n",
�   480 		     argv[0], argv[optind]);
�   481 	  nextchar += strlen (nextchar);
�   482 	  optind++;
�   483 	  return '?';
�   484 	}
�   485 
�   486       if (pfound != NULL)
�   487 	{
�   488 	  option_index = indfound;
�   489 	  optind++;
�   490 	  if (*s)
�   491 	    {
�   492 	      /* Don't test has_arg with >, because some C compilers don't
�   493 		 allow it to be used on enums.  */
�   494 	      if (pfound->has_arg)
�   495 		optarg = s + 1;
�   496 	      else
�   497 		{
�   498 		  if (opterr)
�   499 		    {
�   500 		      if (argv[optind - 1][1] == '-')
�   501 			/* --option */
�   502 			fprintf (stderr,
�   503 				 "%s: option `--%s' doesn't allow an argument\n",
�   504 				 argv[0], pfound->name);
�   505 		      else
�   506 			/* +option or -option */
�   507 			fprintf (stderr,
�   508 			     "%s: option `%c%s' doesn't allow an argument\n",
�   509 			     argv[0], argv[optind - 1][0], pfound->name);
�   510 		    }
�   511 		  nextchar += strlen (nextchar);
�   512 		  return '?';
�   513 		}
�   514 	    }
�   515 	  else if (pfound->has_arg == 1)
�   516 	    {
�   517 	      if (optind < argc)
�   518 		optarg = argv[optind++];
�   519 	      else
�   520 		{
�   521 		  if (opterr)
�   522 		    fprintf (stderr, "%s: option `%s' requires an argument\n",
�   523 			     argv[0], argv[optind - 1]);
�   524 		  nextchar += strlen (nextchar);
�   525 		  return optstring[0] == ':' ? ':' : '?';
�   526 		}
�   527 	    }
�   528 	  nextchar += strlen (nextchar);
�   529 	  if (longind != NULL)
�   530 	    *longind = option_index;
�   531 	  if (pfound->flag)
�   532 	    {
�   533 	      *(pfound->flag) = pfound->val;
�   534 	      return 0;
�   535 	    }
�   536 	  return pfound->val;
�   537 	}
�   538       /* Can't find it as a long option.  If this is not getopt_long_only,
�   539 	 or the option starts with '--' or is not a valid short
�   540 	 option, then it's an error.
�   541 	 Otherwise interpret it as a short option.  */
�   542       if (!long_only || argv[optind][1] == '-'
�   543 #ifdef GETOPT_COMPAT
�   544 	  || argv[optind][0] == '+'
�   545 #endif				/* GETOPT_COMPAT */
�   546 	  || my_index (optstring, *nextchar) == NULL)
�   547 	{
�   548 	  if (opterr)
�   549 	    {
�   550 	      if (argv[optind][1] == '-')
�   551 		/* --option */
�   552 		fprintf (stderr, "%s: unrecognized option `--%s'\n",
�   553 			 argv[0], nextchar);
�   554 	      else
�   555 		/* +option or -option */
�   556 		fprintf (stderr, "%s: unrecognized option `%c%s'\n",
�   557 			 argv[0], argv[optind][0], nextchar);
�   558 	    }
�   559 	  nextchar = (char *) "";
�   560 	  optind++;
�   561 	  return '?';
�   562 	}
�   563     }
�   564 
�   565   /* Look at and handle the next option-character.  */
�   566 
�   567   {
�   568     char c = *nextchar++;
�   569     char *temp = my_index (optstring, c);
�   570 
�   571     /* Increment `optind' when we start to process its last character.  */
�   572     if (*nextchar == '\0')
�   573       ++optind;
�   574 
�   575     if (temp == NULL || c == ':')
�   576       {
�   577 	if (opterr)
�   578 	  {
�   579 #if 0
�   580 	    if (c < 040 || c >= 0177)
�   581 	      fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
�   582 		       argv[0], c);
�   583 	    else
�   584 	      fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
�   585 #else
�   586 	    /* 1003.2 specifies the format of this message.  */
�   587 	    fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
�   588 #endif
�   589 	  }
�   590 	optopt = c;
�   591 	return '?';
�   592       }
�   593     if (temp[1] == ':')
�   594       {
�   595 	if (temp[2] == ':')
�   596 	  {
�   597 	    /* This is an option that accepts an argument optionally.  */
�   598 	    if (*nextchar != '\0')
�   599 	      {
�   600 		optarg = nextchar;
�   601 		optind++;
�   602 	      }
�   603 	    else
�   604 	      optarg = 0;
�   605 	    nextchar = NULL;
�   606 	  }
�   607 	else
�   608 	  {
�   609 	    /* This is an option that requires an argument.  */
�   610 	    if (*nextchar != '\0')
�   611 	      {
�   612 		optarg = nextchar;
�   613 		/* If we end this ARGV-element by taking the rest as an arg,
�   614 		   we must advance to the next element now.  */
�   615 		optind++;
�   616 	      }
�   617 	    else if (optind == argc)
�   618 	      {
�   619 		if (opterr)
�   620 		  {
�   621 #if 0
�   622 		    fprintf (stderr, "%s: option `-%c' requires an argument\n",
�   623 			     argv[0], c);
�   624 #else
�   625 		    /* 1003.2 specifies the format of this message.  */
�   626 		    fprintf (stderr, "%s: option requires an argument -- %c\n",
�   627 			     argv[0], c);
�   628 #endif
�   629 		  }
�   630 		optopt = c;
�   631 		if (optstring[0] == ':')
�   632 		  c = ':';
�   633 		else
�   634 		  c = '?';
�   635 	      }
�   636 	    else
�   637 	      /* We already incremented `optind' once;
�   638 		 increment it again when taking next ARGV-elt as argument.  */
�   639 	      optarg = argv[optind++];
�   640 	    nextchar = NULL;
�   641 	  }
�   642       }
�   643     return c;
�   644   }
�   645 }
�   646 
�   647 int
�   648 getopt (argc, argv, optstring)
�   649      int argc;
�   650      char *const *argv;
�   651      const char *optstring;
�   652 {
�   653   return _getopt_internal (argc, argv, optstring,
�   654 			   (const struct option *) 0,
�   655 			   (int *) 0,
�   656 			   0);
�   657 }
�   658 
�   659 #endif	/* _LIBC or not __GNU_LIBRARY__.  */
�   660 
�   661 #ifdef TEST
�   662 
�   663 /* Compile with -DTEST to make an executable for use in testing
�   664    the above definition of `getopt'.  */
�   665 
�   666 int
�   667 main (argc, argv)
�   668      int argc;
�   669      char **argv;
�   670 {
�   671   int c;
�   672   int digit_optind = 0;
�   673 
�   674   while (1)
�   675     {
�   676       int this_option_optind = optind ? optind : 1;
�   677 
�   678       c = getopt (argc, argv, "abc:d:0123456789");
�   679       if (c == EOF)
�   680 	break;
�   681 
�   682       switch (c)
�   683 	{
�   684 	case '0':
�   685 	case '1':
�   686 	case '2':
�   687 	case '3':
�   688 	case '4':
�   689 	case '5':
�   690 	case '6':
�   691 	case '7':
�   692 	case '8':
�   693 	case '9':
�   694 	  if (digit_optind != 0 && digit_optind != this_option_optind)
�   695 	    printf ("digits occur in two different argv-elements.\n");
�   696 	  digit_optind = this_option_optind;
�   697 	  printf ("option %c\n", c);
�   698 	  break;
�   699 
�   700 	case 'a':
�   701 	  printf ("option a\n");
�   702 	  break;
�   703 
�   704 	case 'b':
�   705 	  printf ("option b\n");
�   706 	  break;
�   707 
�   708 	case 'c':
�   709 	  printf ("option c with value `%s'\n", optarg);
�   710 	  break;
�   711 
�   712 	case '?':
�   713 	  break;
�   714 
�   715 	default:
�   716 	  printf ("?? getopt returned character code 0%o ??\n", c);
�   717 	}
�   718     }
�   719 
�   720   if (optind < argc)
�   721     {
�   722       printf ("non-option ARGV-elements: ");
�   723       while (optind < argc)
�   724 	printf ("%s ", argv[optind++]);
�   725       printf ("\n");
�   726     }
�   727 
�   728   exit (0);
�   729 }
�   730 
�   731 #endif /* TEST */