Take getopt from glibc, disable -W foo support as in the earlier version, size shrink 5%, hope it solves option parsing w/ busybox tar

1 files changed, 882 insertions, 495 deletions

diff --git a/libc/unistd/getopt.c b/libc/unistd/getopt.c
index 974f5b876..cffde47e1 100644
--- a/libc/unistd/getopt.c
+++ b/libc/unistd/getopt.c
@@ -2,7 +2,7 @@
    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!
-   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001
+   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004
    	Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
@@ -25,26 +25,85 @@
  * Modified for uClibc by Manuel Novoa III on 1/5/01.
  * Modified once again for uClibc by Erik Andersen 8/7/02
  */
+
+/* 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
+# define _NO_PROTO
+#endif
 
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#define __FORCE_GLIBC
 #include <features.h>
+
 #include <stdio.h>
+
+/* Comment out all this code if we are using the GNU C Library, and are not
+   actually compiling the library itself.  This code is part of the GNU C
+   Library, but also included in many other GNU distributions.  Compiling
+   and linking in this code is a waste when using the GNU C library
+   (especially if it is a shared library).  Rather than having every GNU
+   program understand `configure --with-gnu-libc' and omit the object files,
+   it is simpler to just do this in the source for each such file.  */
+
+#define GETOPT_INTERFACE_VERSION 2
+#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
+# include <gnu-versions.h>
+# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
+#  define ELIDE_CODE
+# endif
+#endif
+
+#ifndef ELIDE_CODE
+
+
+/* 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.  */
+# include <stdlib.h>
+# include <unistd.h>
+#endif	/* GNU C library.  */
+
 #include <string.h>
-#include <stdlib.h>
-#ifdef __UCLIBC_HAS_GETTEXT_AWARENESS__
-#include <libintl.h>
+
+#ifdef VMS
+# include <unixlib.h>
 #endif
 
+#if !defined __UCLIBC__ && !defined __UCLIBC_HAS_GETTEXT_AWARENESS__
+#ifdef _LIBC
+# include <libintl.h>
+#else
+# include "gettext.h"
+# define _(msgid) gettext (msgid)
+#endif
+#else
 #ifdef __UCLIBC_MJN3_ONLY__
 #warning TODO: Enable gettext awareness.
 #endif /* __UCLIBC_MJN3_ONLY__ */
 
 #undef _
-#define _(X)   X
+#define _(X)	X
+
+#endif
 
 /* Treat '-W foo' the same as the long option '--foo',
  * disabled for the moment since it costs about 2k... */
 #undef SPECIAL_TREATMENT_FOR_W
 
+#if defined _LIBC && defined USE_IN_LIBIO
+# include <wchar.h>
+#endif
+
+#ifndef attribute_hidden
+# define attribute_hidden
+#endif
+
 /* This version of `getopt' appears to the caller like standard Unix `getopt'
    but it behaves differently for the user, since it allows the user
    to intersperse the options with the other arguments.
@@ -60,6 +119,7 @@
    they can distinguish the relative order of options and other arguments.  */
 
 #include <getopt.h>
+#include "getopt_int.h"
 
 libc_hidden_proto(strchr)
 libc_hidden_proto(strcmp)
@@ -69,17 +129,13 @@ libc_hidden_proto(getenv)
 libc_hidden_proto(fprintf)
 libc_hidden_proto(stderr)
 
-extern int _getopt_internal (int argc, char *const *argv, const char *optstring, 
-	const struct option *longopts, int *longind, int long_only) attribute_hidden;
-
-
 /* 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.  */
 
-char *optarg = NULL;
+char *optarg;
 
 /* Index in ARGV of the next element to be scanned.
    This is used for communication to and from the caller
@@ -107,66 +163,49 @@ int opterr = 1;
 
 int optopt = '?';
 
-/* The next char to be scanned in the option-element
-   in which the last option character we returned was found.
-   This allows us to pick up the scan where we left off.
-
-   If this is zero, or a null string, it means resume the scan
-   by advancing to the next ARGV-element.  */
-
-static char *nextchar;
-
-/* Formerly, initialization of getopt depended on optind==0, which
-   causes problems with re-calling getopt as programs generally don't
-   know that. */
-
-static int __getopt_initialized;
-
-/* Describe how to deal with options that follow non-option ARGV-elements.
-
-   If the caller did not specify anything,
-   the default is REQUIRE_ORDER if the environment variable
-   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+/* Keep a global copy of all internal members of getopt_data.  */
 
-   REQUIRE_ORDER means don't recognize them as options;
-   stop option processing when the first non-option is seen.
-   This is what Unix does.
-   This mode of operation is selected by either setting the environment
-   variable POSIXLY_CORRECT, or using `+' as the first character
-   of the list of option characters.
+static struct _getopt_data getopt_data;
 
-   PERMUTE is the default.  We permute the contents of ARGV as we scan,
-   so that eventually all the non-options are at the end.  This allows options
-   to be given in any order, even with programs that were not written to
-   expect this.
-
-   RETURN_IN_ORDER is an option available to programs that were written
-   to expect options and other ARGV-elements in any order and that care about
-   the ordering of the two.  We describe each non-option ARGV-element
-   as if it were the argument of an option with character code 1.
-   Using `-' as the first character of the list of option characters
-   selects this mode of operation.
+
+#ifndef __GNU_LIBRARY__
 
-   The special argument `--' forces an end of option-scanning regardless
-   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
-   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
 
-static enum
-{
-  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
-} ordering;
+#ifndef getenv
+extern char *getenv ();
+#endif
 
-# include <string.h>
-# define my_index	strchr
+#endif /* not __GNU_LIBRARY__ */
 
-/* Handle permutation of arguments.  */
-
-/* Describe the part of ARGV that contains non-options that have
-   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
-   `last_nonopt' is the index after the last of them.  */
-
-static int first_nonopt;
-static int last_nonopt;
+#ifdef _LIBC
+/* 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).  */
+# ifdef USE_NONOPTION_FLAGS
+extern int __libc_argc;
+extern char **__libc_argv;
+
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+#  define SWAP_FLAGS(ch1, ch2) \
+  if (d->__nonoption_flags_len > 0)					      \
+    {									      \
+      char __tmp = __getopt_nonoption_flags[ch1];			      \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
+      __getopt_nonoption_flags[ch2] = __tmp;				      \
+    }
+# else
+#  define SWAP_FLAGS(ch1, ch2)
+# endif
+#else	/* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif	/* _LIBC */
 
 /* Exchange two adjacent subsequences of ARGV.
    One subsequence is elements [first_nonopt,last_nonopt)
@@ -177,90 +216,149 @@ static int last_nonopt;
    `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 exchange (char **argv)
+static void
+exchange (char **argv, struct _getopt_data *d)
 {
-    int bottom = first_nonopt;
-    int middle = last_nonopt;
-    int top = 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.  */
+  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.  */
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+  /* 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.  */
+  if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
+    {
+      /* 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)
+	d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
+      else
+	{
+	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
+			     d->__nonoption_flags_max_len),
+		  '\0', top + 1 - d->__nonoption_flags_max_len);
+	  d->__nonoption_flags_max_len = top + 1;
+	  __getopt_nonoption_flags = new_str;
+	}
+    }
+#endif
 
-    while (top > middle && middle > bottom)
+  while (top > middle && middle > bottom)
     {
-	if (top - middle > middle - bottom)
+      if (top - middle > middle - bottom)
 	{
-	    /* Bottom segment is the short one.  */
-	    int len = middle - bottom;
-	    register int i;
+	  /* 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++)
+	  /* 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;
+	      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;
+	  /* Exclude the moved bottom segment from further swapping.  */
+	  top -= len;
 	}
-	else
+      else
 	{
-	    /* Top segment is the short one.  */
-	    int len = top - middle;
-	    register int i;
+	  /* 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++)
+	  /* 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;
+	      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;
+	  /* Exclude the moved top segment from further swapping.  */
+	  bottom += len;
 	}
     }
 
-    /* Update records for the slots the non-options now occupy.  */
+  /* Update records for the slots the non-options now occupy.  */
 
-    first_nonopt += (optind - last_nonopt);
-    last_nonopt = optind;
+  d->__first_nonopt += (d->optind - d->__last_nonopt);
+  d->__last_nonopt = d->optind;
 }
 
 /* Initialize the internal data when the first call is made.  */
 
-static const char *_getopt_initialize (attribute_unused int argc, attribute_unused char *const * argv, const char *optstring)
+static const char *
+_getopt_initialize (attribute_unused int argc, attribute_unused char *const *argv, const char *optstring,
+		    struct _getopt_data *d)
 {
-    /* 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.  */
+  /* 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.  */
+
+  d->__first_nonopt = d->__last_nonopt = d->optind;
 
-    first_nonopt = last_nonopt = optind;
+  d->__nextchar = NULL;
 
-    nextchar = NULL;
+  d->__posixly_correct = !!getenv ("POSIXLY_CORRECT");
 
-    /* Determine how to handle the ordering of options and nonoptions.  */
+  /* Determine how to handle the ordering of options and nonoptions.  */
 
-    if (optstring[0] == '-')
+  if (optstring[0] == '-')
+    {
+      d->__ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
     {
-	ordering = RETURN_IN_ORDER;
-	++optstring;
+      d->__ordering = REQUIRE_ORDER;
+      ++optstring;
     }
-    else if (optstring[0] == '+')
+  else if (d->__posixly_correct)
+    d->__ordering = REQUIRE_ORDER;
+  else
+    d->__ordering = PERMUTE;
+
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+  if (!d->__posixly_correct
+      && argc == __libc_argc && argv == __libc_argv)
     {
-	ordering = REQUIRE_ORDER;
-	++optstring;
+      if (d->__nonoption_flags_max_len == 0)
+	{
+	  if (__getopt_nonoption_flags == NULL
+	      || __getopt_nonoption_flags[0] == '\0')
+	    d->__nonoption_flags_max_len = -1;
+	  else
+	    {
+	      const char *orig_str = __getopt_nonoption_flags;
+	      int len = d->__nonoption_flags_max_len = strlen (orig_str);
+	      if (d->__nonoption_flags_max_len < argc)
+		d->__nonoption_flags_max_len = argc;
+	      __getopt_nonoption_flags =
+		(char *) malloc (d->__nonoption_flags_max_len);
+	      if (__getopt_nonoption_flags == NULL)
+		d->__nonoption_flags_max_len = -1;
+	      else
+		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+			'\0', d->__nonoption_flags_max_len - len);
+	    }
+	}
+      d->__nonoption_flags_len = d->__nonoption_flags_max_len;
     }
-    else if (getenv ("POSIXLY_CORRECT") != NULL)
-	ordering = REQUIRE_ORDER;
-    else
-	ordering = PERMUTE;
+  else
+    d->__nonoption_flags_len = 0;
+#endif
 
-    return optstring;
+  return optstring;
 }
 
 /* Scan elements of ARGV (whose length is ARGC) for option characters
@@ -319,489 +417,776 @@ static const char *_getopt_initialize (attribute_unused int argc, attribute_unus
    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
    long-named options.  */
 
-int _getopt_internal (int argc, char *const *argv, const char *optstring, 
-	const struct option *longopts, int *longind, int long_only)
+static int
+_getopt_internal_r (int argc, char *const *argv, const char *optstring,
+		    const struct option *longopts, int *longind,
+		    int long_only, struct _getopt_data *d)
 {
-    int print_errors = opterr;
-    if (optstring[0] == ':')
-	print_errors = 0;
+  int print_errors = d->opterr;
+  if (optstring[0] == ':')
+    print_errors = 0;
 
-    if (argc < 1)
-	return -1;
+  if (argc < 1)
+    return -1;
 
-    optarg = NULL;
+  d->optarg = NULL;
 
-    if (optind == 0 || !__getopt_initialized)
+  if (d->optind == 0 || !d->__initialized)
     {
-	if (optind == 0)
-	    optind = 1;	/* Don't scan ARGV[0], the program name.  */
-	optstring = _getopt_initialize (argc, argv, optstring);
-	__getopt_initialized = 1;
+      if (d->optind == 0)
+	d->optind = 1;	/* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize (argc, argv, optstring, d);
+      d->__initialized = 1;
     }
 
-    /* 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.  */
-#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+  /* 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.  */
+#if defined _LIBC && defined USE_NONOPTION_FLAGS
+# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
+		      || (d->optind < d->__nonoption_flags_len		      \
+			  && __getopt_nonoption_flags[d->optind] == '1'))
+#else
+# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
+#endif
 
-    if (nextchar == NULL || *nextchar == '\0')
+  if (d->__nextchar == NULL || *d->__nextchar == '\0')
     {
-	/* Advance to the next ARGV-element.  */
+      /* 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).  */
-	if (last_nonopt > optind)
-	    last_nonopt = optind;
-	if (first_nonopt > optind)
-	    first_nonopt = optind;
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
+	 moved back by the user (who may also have changed the arguments).  */
+      if (d->__last_nonopt > d->optind)
+	d->__last_nonopt = d->optind;
+      if (d->__first_nonopt > d->optind)
+	d->__first_nonopt = d->optind;
 
-	if (ordering == PERMUTE)
+      if (d->__ordering == PERMUTE)
 	{
-	    /* If we have just processed some options following some non-options,
-	       exchange them so that the options come first.  */
+	  /* If we have just processed some options following some non-options,
+	     exchange them so that the options come first.  */
 
-	    if (first_nonopt != last_nonopt && last_nonopt != optind)
-		exchange ((char **) argv);
-	    else if (last_nonopt != optind)
-		first_nonopt = optind;
+	  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;
 
-	    /* Skip any additional non-options
-	       and extend the range of non-options previously skipped.  */
+	  /* Skip any additional non-options
+	     and extend the range of non-options previously skipped.  */
 
-	    while (optind < argc && NONOPTION_P)
-		optind++;
-	    last_nonopt = optind;
+	  while (d->optind < argc && NONOPTION_P)
+	    d->optind++;
+	  d->__last_nonopt = d->optind;
 	}
 
-	/* 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.  */
+      /* 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.  */
 
-	if (optind != argc && !strcmp (argv[optind], "--"))
+      if (d->optind != argc && !strcmp (argv[d->optind], "--"))
 	{
-	    optind++;
+	  d->optind++;
 
-	    if (first_nonopt != last_nonopt && last_nonopt != optind)
-		exchange ((char **) argv);
-	    else if (first_nonopt == last_nonopt)
-		first_nonopt = optind;
-	    last_nonopt = argc;
+	  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;
 
-	    optind = argc;
+	  d->optind = argc;
 	}
 
-	/* If we have done all the ARGV-elements, stop the scan
-	   and back over any non-options that we skipped and permuted.  */
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
 
-	if (optind == argc)
+      if (d->optind == argc)
 	{
-	    /* Set the next-arg-index to point at the non-options
-	       that we previously skipped, so the caller will digest them.  */
-	    if (first_nonopt != last_nonopt)
-		optind = first_nonopt;
-	    return -1;
+	  /* 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;
 	}
 
-	/* 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 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)
+      if (NONOPTION_P)
 	{
-	    if (ordering == REQUIRE_ORDER)
-		return -1;
-	    optarg = argv[optind++];
-	    return 1;
+	  if (d->__ordering == REQUIRE_ORDER)
+	    return -1;
+	  d->optarg = argv[d->optind++];
+	  return 1;
 	}
 
-	/* We have found another option-ARGV-element.
-	   Skip the initial punctuation.  */
+      /* We have found another option-ARGV-element.
+	 Skip the initial punctuation.  */
 
-	nextchar = (argv[optind] + 1
-		+ (longopts != NULL && argv[optind][1] == '-'));
+      d->__nextchar = (argv[d->optind] + 1
+		  + (longopts != NULL && argv[d->optind][1] == '-'));
     }
 
-    /* Decode the current option-ARGV-element.  */
+  /* Decode the current option-ARGV-element.  */
 
-    /* Check whether the ARGV-element is a long option.
+  /* 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.
+     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".
+     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.  */
+     This distinction seems to be the most useful approach.  */
 
-    if (longopts != NULL
-	    && (argv[optind][1] == '-'
-		|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+  if (longopts != NULL
+      && (argv[d->optind][1] == '-'
+	  || (long_only && (argv[d->optind][2]
+			    || !strchr (optstring, argv[d->optind][1])))))
     {
-	char *nameend;
-	const struct option *p;
-	const struct option *pfound = NULL;
-	int exact = 0;
-	int ambig = 0;
-	int indfound = -1;
-	int option_index;
-
-	for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
-	    /* Do nothing.  */ ;
-
-	/* Test all long options for either exact match
-	   or abbreviated matches.  */
-	for (p = longopts, option_index = 0; p->name; p++, option_index++)
-	    if (!strncmp (p->name, nextchar, nameend - nextchar))
+      char *nameend;
+      const struct option *p;
+      const struct option *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = -1;
+      int option_index;
+
+      for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
+	/* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+	 or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
+	  {
+	    if ((unsigned int) (nameend - d->__nextchar)
+		== (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;
+	      }
+	    else if (long_only
+		     || pfound->has_arg != p->has_arg
+		     || pfound->flag != p->flag
+		     || pfound->val != p->val)
+	      /* Second or later nonexact match found.  */
+	      ambig = 1;
+	  }
+
+      if (ambig && !exact)
+	{
+	  if (print_errors)
 	    {
-		if ((unsigned int) (nameend - nextchar)
-			== (unsigned int) strlen (p->name))
-		{
-		    /* Exact match found.  */
-		    pfound = p;
-		    indfound = option_index;
-		    exact = 1;
-		    break;
-		}
-		else if (pfound == NULL)
+#if defined _LIBC && defined USE_IN_LIBIO
+	      char *buf;
+
+	      if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"),
+			      argv[0], argv[d->optind]) >= 0)
 		{
-		    /* 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.  */
-		    ambig = 1;
-	    }
+		  _IO_flockfile (stderr);
 
-	if (ambig && !exact)
-	{
-	    if (print_errors)
-	    {
-		fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
-			argv[0], argv[optind]);
+		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+		  __fxprintf (NULL, "%s", buf);
+
+		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+		  _IO_funlockfile (stderr);
+
+		  free (buf);
+		}
+#else
+	      fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+		       argv[0], argv[d->optind]);
+#endif
 	    }
-	    nextchar += strlen (nextchar);
-	    optind++;
-	    optopt = 0;
-	    return '?';
+	  d->__nextchar += strlen (d->__nextchar);
+	  d->optind++;
+	  d->optopt = 0;
+	  return '?';
 	}
 
-	if (pfound != NULL)
+      if (pfound != NULL)
 	{
-	    option_index = indfound;
-	    optind++;
-	    if (*nameend)
+	  option_index = indfound;
+	  d->optind++;
+	  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)
-		    optarg = nameend + 1;
-		else
+	      /* 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)
+		  if (print_errors)
 		    {
+#if defined _LIBC && defined USE_IN_LIBIO
+		      char *buf;
+		      int n;
+#endif
 
-			if (argv[optind - 1][1] == '-')
+		      if (argv[d->optind - 1][1] == '-')
 			{
-			    /* --option */
-			    fprintf (stderr, _("\
-					%s: option `--%s' doesn't allow an argument\n"),
-				    argv[0], pfound->name);
+			  /* --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
 			}
-			else
+		      else
 			{
-			    /* +option or -option */
-			    fprintf (stderr, _("\
-					%s: option `%c%s' doesn't allow an argument\n"),
-				    argv[0], argv[optind - 1][0], pfound->name);
+			  /* +option or -option */
+#if defined _LIBC && defined USE_IN_LIBIO
+			  n = __asprintf (&buf, _("\
+%s: option `%c%s' doesn't allow an argument\n"),
+					  argv[0], argv[d->optind - 1][0],
+					  pfound->name);
+#else
+			  fprintf (stderr, _("\
+%s: option `%c%s' doesn't allow an argument\n"),
+				   argv[0], argv[d->optind - 1][0],
+				   pfound->name);
+#endif
 			}
 
+#if defined _LIBC && defined USE_IN_LIBIO
+		      if (n >= 0)
+			{
+			  _IO_flockfile (stderr);
+
+			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+			  ((_IO_FILE *) stderr)->_flags2
+			    |= _IO_FLAGS2_NOTCANCEL;
+
+			  __fxprintf (NULL, "%s", buf);
+
+			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+			  _IO_funlockfile (stderr);
+
+			  free (buf);
+			}
+#endif
 		    }
 
-		    nextchar += strlen (nextchar);
+		  d->__nextchar += strlen (d->__nextchar);
 
-		    optopt = pfound->val;
-		    return '?';
+		  d->optopt = pfound->val;
+		  return '?';
 		}
 	    }
-	    else if (pfound->has_arg == 1)
+	  else if (pfound->has_arg == 1)
 	    {
-		if (optind < argc)
-		    optarg = argv[optind++];
-		else
+	      if (d->optind < argc)
+		d->optarg = argv[d->optind++];
+	      else
 		{
-		    if (print_errors)
+		  if (print_errors)
 		    {
-			fprintf (stderr,
-				_("%s: option `%s' requires an argument\n"),
-				argv[0], argv[optind - 1]);
+#if defined _LIBC && defined USE_IN_LIBIO
+		      char *buf;
+
+		      if (__asprintf (&buf, _("\
+%s: option `%s' requires an argument\n"),
+				      argv[0], argv[d->optind - 1]) >= 0)
+			{
+			  _IO_flockfile (stderr);
+
+			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+			  ((_IO_FILE *) stderr)->_flags2
+			    |= _IO_FLAGS2_NOTCANCEL;
+
+			  __fxprintf (NULL, "%s", buf);
+
+			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+			  _IO_funlockfile (stderr);
+
+			  free (buf);
+			}
+#else
+		      fprintf (stderr,
+			       _("%s: option `%s' requires an argument\n"),
+			       argv[0], argv[d->optind - 1]);
+#endif
 		    }
-		    nextchar += strlen (nextchar);
-		    optopt = pfound->val;
-		    return optstring[0] == ':' ? ':' : '?';
+		  d->__nextchar += strlen (d->__nextchar);
+		  d->optopt = pfound->val;
+		  return optstring[0] == ':' ? ':' : '?';
 		}
 	    }
-	    nextchar += strlen (nextchar);
-	    if (longind != NULL)
-		*longind = option_index;
-	    if (pfound->flag)
+	  d->__nextchar += strlen (d->__nextchar);
+	  if (longind != NULL)
+	    *longind = option_index;
+	  if (pfound->flag)
 	    {
-		*(pfound->flag) = pfound->val;
-		return 0;
+	      *(pfound->flag) = pfound->val;
+	      return 0;
 	    }
-	    return pfound->val;
+	  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.  */
-	if (!long_only || argv[optind][1] == '-'
-		|| my_index (optstring, *nextchar) == 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.
+	 Otherwise interpret it as a short option.  */
+      if (!long_only || argv[d->optind][1] == '-'
+	  || strchr (optstring, *d->__nextchar) == NULL)
 	{
-	    if (print_errors)
+	  if (print_errors)
 	    {
+#if defined _LIBC && defined USE_IN_LIBIO
+	      char *buf;
+	      int n;
+#endif
 
-		if (argv[optind][1] == '-')
+	      if (argv[d->optind][1] == '-')
 		{
-		    /* --option */
-		    fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
-			    argv[0], nextchar);
+		  /* --option */
+#if defined _LIBC && defined USE_IN_LIBIO
+		  n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"),
+				  argv[0], d->__nextchar);
+#else
+		  fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+			   argv[0], d->__nextchar);
+#endif
 		}
-		else
+	      else
 		{
-		    /* +option or -option */
-		    fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
-			    argv[0], argv[optind][0], nextchar);
+		  /* +option or -option */
+#if defined _LIBC && defined USE_IN_LIBIO
+		  n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"),
+				  argv[0], argv[d->optind][0], d->__nextchar);
+#else
+		  fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+			   argv[0], argv[d->optind][0], d->__nextchar);
+#endif
 		}
 
+#if defined _LIBC && defined USE_IN_LIBIO
+	      if (n >= 0)
+		{
+		  _IO_flockfile (stderr);
+
+		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+		  __fxprintf (NULL, "%s", buf);
+
+		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+		  _IO_funlockfile (stderr);
+
+		  free (buf);
+		}
+#endif
 	    }
-	    nextchar = (char *) "";
-	    optind++;
-	    optopt = 0;
-	    return '?';
+	  d->__nextchar = (char *) "";
+	  d->optind++;
+	  d->optopt = 0;
+	  return '?';
 	}
     }
 
-    /* Look at and handle the next short option-character.  */
+  /* Look at and handle the next short option-character.  */
 
-    {
-	char c = *nextchar++;
-	char *temp = my_index (optstring, c);
+  {
+    char c = *d->__nextchar++;
+    char *temp = strchr (optstring, c);
 
-	/* Increment `optind' when we start to process its last character.  */
-	if (*nextchar == '\0')
-	    ++optind;
+    /* Increment `optind' when we start to process its last character.  */
+    if (*d->__nextchar == '\0')
+      ++d->optind;
 
-	if (temp == NULL || c == ':')
-	{
-	    if (print_errors)
-	    {
-		    /* 1003.2 specifies the format of this message.  */
-		    fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
-	    }
-	    optopt = c;
-	    return '?';
-	}
+    if (temp == NULL || c == ':')
+      {
+	if (print_errors)
+	  {
+#if defined _LIBC && defined USE_IN_LIBIO
+	      char *buf;
+	      int n;
+#endif
+
+	    if (d->__posixly_correct)
+	      {
+		/* 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
+	      }
+	    else
+	      {
+#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)
+	      {
+		_IO_flockfile (stderr);
+
+		int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+		((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+		__fxprintf (NULL, "%s", buf);
+
+		((_IO_FILE *) stderr)->_flags2 = old_flags2;
+		_IO_funlockfile (stderr);
+
+		free (buf);
+	      }
+#endif
+	  }
+	d->optopt = c;
+	return '?';
+      }
 #ifdef SPECIAL_TREATMENT_FOR_W
-	/* 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;
+    /* 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.  */
-	    if (*nextchar != '\0')
-	    {
-		optarg = nextchar;
-		/* If we end this ARGV-element by taking the rest as an arg,
-		   we must advance to the next element now.  */
-		optind++;
-	    }
-	    else if (optind == argc)
-	    {
-		if (print_errors)
-		{
-		    /* 1003.2 specifies the format of this message.  */
-		    fprintf (stderr, _("%s: option requires an argument -- %c\n"),
-			    argv[0], c);
-		}
-		optopt = c;
-		if (optstring[0] == ':')
-		    c = ':';
-		else
-		    c = '?';
-		return c;
-	    }
+	/* 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)
+	      {
+		/* 1003.2 specifies the format of this message.  */
+#if defined _LIBC && defined USE_IN_LIBIO
+		char *buf;
+
+		if (__asprintf (&buf,
+				_("%s: option requires an argument -- %c\n"),
+				argv[0], c) >= 0)
+		  {
+		    _IO_flockfile (stderr);
+
+		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+		    __fxprintf (NULL, "%s", buf);
+
+		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+		    _IO_funlockfile (stderr);
+
+		    free (buf);
+		  }
+#else
+		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+			 argv[0], c);
+#endif
+	      }
+	    d->optopt = c;
+	    if (optstring[0] == ':')
+	      c = ':';
 	    else
-		/* We already incremented `optind' once;
-		   increment it again when taking next ARGV-elt as argument.  */
-		optarg = argv[optind++];
+	      c = '?';
+	    return c;
+	  }
+	else
+	  /* We already incremented `d->optind' once;
+	     increment it again when taking next ARGV-elt as argument.  */
+	  d->optarg = argv[d->optind++];
 
-	    /* optarg is now the argument, see if it's in the
-	       table of longopts.  */
+	/* optarg is now the argument, see if it's in the
+	   table of longopts.  */
 
-	    for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
-		/* Do nothing.  */ ;
+	for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
+	     nameend++)
+	  /* Do nothing.  */ ;
 
-	    /* Test all long options for either exact match
-	       or abbreviated matches.  */
-	    for (p = longopts, option_index = 0; p->name; p++, option_index++)
-		if (!strncmp (p->name, nextchar, nameend - nextchar))
-		{
-		    if ((unsigned int) (nameend - nextchar) == 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;
-		    }
-		    else
-			/* Second or later nonexact match found.  */
-			ambig = 1;
-		}
-	    if (ambig && !exact)
-	    {
-		if (print_errors)
-		{
-		    fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
-			    argv[0], argv[optind]);
-		}
-		nextchar += strlen (nextchar);
-		optind++;
-		return '?';
-	    }
-	    if (pfound != NULL)
+	/* Test all long options for either exact match
+	   or abbreviated matches.  */
+	for (p = longopts, option_index = 0; p->name; p++, option_index++)
+	  if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
 	    {
-		option_index = indfound;
-		if (*nameend)
+	      if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
 		{
-		    /* Don't test has_arg with >, because some C compilers don't
-		       allow it to be used on enums.  */
-		    if (pfound->has_arg)
-			optarg = nameend + 1;
-		    else
-		    {
-			if (print_errors)
-			{
-			    fprintf (stderr, _("\
-					%s: option `-W %s' doesn't allow an argument\n"),
-				    argv[0], pfound->name);
-			}
-
-			nextchar += strlen (nextchar);
-			return '?';
-		    }
+		  /* Exact match found.  */
+		  pfound = p;
+		  indfound = option_index;
+		  exact = 1;
+		  break;
 		}
-		else if (pfound->has_arg == 1)
+	      else if (pfound == NULL)
 		{
-		    if (optind < argc)
-			optarg = argv[optind++];
-		    else
-		    {
-			if (print_errors)
-			{
-			    fprintf (stderr,
-				    _("%s: option `%s' requires an argument\n"),
-				    argv[0], argv[optind - 1]);
-			}
-			nextchar += strlen (nextchar);
-			return optstring[0] == ':' ? ':' : '?';
-		    }
-		}
-		nextchar += strlen (nextchar);
-		if (longind != NULL)
-		    *longind = option_index;
-		if (pfound->flag)
-		{
-		    *(pfound->flag) = pfound->val;
-		    return 0;
+		  /* First nonexact match found.  */
+		  pfound = p;
+		  indfound = option_index;
 		}
-		return pfound->val;
+	      else
+		/* Second or later nonexact match found.  */
+		ambig = 1;
 	    }
-	    nextchar = NULL;
-	    return 'W';	/* Let the application handle it.   */
-	}
+	if (ambig && !exact)
+	  {
+	    if (print_errors)
+	      {
+#if defined _LIBC && defined USE_IN_LIBIO
+		char *buf;
+
+		if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"),
+				argv[0], argv[d->optind]) >= 0)
+		  {
+		    _IO_flockfile (stderr);
+
+		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+		    __fxprintf (NULL, "%s", buf);
+
+		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+		    _IO_funlockfile (stderr);
+
+		    free (buf);
+		  }
+#else
+		fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+			 argv[0], argv[d->optind]);
 #endif
-	if (temp[1] == ':')
-	{
-	    if (temp[2] == ':')
-	    {
-		/* This is an option that accepts an argument optionally.  */
-		if (*nextchar != '\0')
-		{
-		    optarg = nextchar;
-		    optind++;
-		}
+	      }
+	    d->__nextchar += strlen (d->__nextchar);
+	    d->optind++;
+	    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)
+		  d->optarg = nameend + 1;
 		else
-		    optarg = NULL;
-		nextchar = NULL;
-	    }
-	    else
-	    {
-		/* This is an option that requires an argument.  */
-		if (*nextchar != '\0')
-		{
-		    optarg = nextchar;
-		    /* If we end this ARGV-element by taking the rest as an arg,
-		       we must advance to the next element now.  */
-		    optind++;
-		}
-		else if (optind == argc)
-		{
+		  {
 		    if (print_errors)
-		    {
-			/* 1003.2 specifies the format of this message.  */
+		      {
+#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)
+			  {
+			    _IO_flockfile (stderr);
+
+			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+			    ((_IO_FILE *) stderr)->_flags2
+			      |= _IO_FLAGS2_NOTCANCEL;
+
+			    __fxprintf (NULL, "%s", buf);
+
+			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+			    _IO_funlockfile (stderr);
+
+			    free (buf);
+			  }
+#else
+			fprintf (stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+				 argv[0], pfound->name);
+#endif
+		      }
+
+		    d->__nextchar += strlen (d->__nextchar);
+		    return '?';
+		  }
+	      }
+	    else if (pfound->has_arg == 1)
+	      {
+		if (d->optind < argc)
+		  d->optarg = argv[d->optind++];
+		else
+		  {
+		    if (print_errors)
+		      {
+#if defined _LIBC && defined USE_IN_LIBIO
+			char *buf;
+
+			if (__asprintf (&buf, _("\
+%s: option `%s' requires an argument\n"),
+					argv[0], argv[d->optind - 1]) >= 0)
+			  {
+			    _IO_flockfile (stderr);
+
+			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+			    ((_IO_FILE *) stderr)->_flags2
+			      |= _IO_FLAGS2_NOTCANCEL;
+
+			    __fxprintf (NULL, "%s", buf);
+
+			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
+			    _IO_funlockfile (stderr);
+
+			    free (buf);
+			  }
+#else
 			fprintf (stderr,
-				_("%s: option requires an argument -- %c\n"),
-				argv[0], c);
-		    }
-		    optopt = c;
-		    if (optstring[0] == ':')
-			c = ':';
-		    else
-			c = '?';
-		}
+				 _("%s: option `%s' requires an argument\n"),
+				 argv[0], argv[d->optind - 1]);
+#endif
+		      }
+		    d->__nextchar += strlen (d->__nextchar);
+		    return optstring[0] == ':' ? ':' : '?';
+		  }
+	      }
+	    d->__nextchar += strlen (d->__nextchar);
+	    if (longind != NULL)
+	      *longind = option_index;
+	    if (pfound->flag)
+	      {
+		*(pfound->flag) = pfound->val;
+		return 0;
+	      }
+	    return pfound->val;
+	  }
+	  d->__nextchar = NULL;
+	  return 'W';	/* Let the application handle it.   */
+      }
+#endif
+    if (temp[1] == ':')
+      {
+	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)
+		  {
+		    /* 1003.2 specifies the format of this message.  */
+#if defined _LIBC && defined USE_IN_LIBIO
+		    char *buf;
+
+		    if (__asprintf (&buf, _("\
+%s: option requires an argument -- %c\n"),
+				    argv[0], c) >= 0)
+		      {
+			_IO_flockfile (stderr);
+
+			int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
+			((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
+
+			__fxprintf (NULL, "%s", buf);
+
+			((_IO_FILE *) stderr)->_flags2 = old_flags2;
+			_IO_funlockfile (stderr);
+
+			free (buf);
+		      }
+#else
+		    fprintf (stderr,
+			     _("%s: option requires an argument -- %c\n"),
+			     argv[0], c);
+#endif
+		  }
+		d->optopt = c;
+		if (optstring[0] == ':')
+		  c = ':';
 		else
-		    /* We already incremented `optind' once;
-		       increment it again when taking next ARGV-elt as argument.  */
-		    optarg = argv[optind++];
-		nextchar = NULL;
-	    }
-	}
-	return c;
-    }
+		  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;
+	  }
+      }
+    return c;
+  }
+}
+
+int
+_getopt_internal (int argc, char *const *argv, const char *optstring,
+		  const struct option *longopts, int *longind, int long_only)
+{
+  int result;
+
+  getopt_data.optind = optind;
+  getopt_data.opterr = opterr;
+
+  result = _getopt_internal_r (argc, argv, optstring, longopts,
+			       longind, long_only, &getopt_data);
+
+  optind = getopt_data.optind;
+  optarg = getopt_data.optarg;
+  optopt = getopt_data.optopt;
+
+  return result;
 }
 
-int getopt (int argc, char *const *argv, const char *optstring)
+int
+getopt (int argc, char *const *argv, const char *optstring)
 {
-    return _getopt_internal (argc, argv, optstring, 
-	    (const struct option *) 0, (int *) 0, 0);
+  return _getopt_internal (argc, argv, optstring,
+			   (const struct option *) 0,
+			   (int *) 0,
+			   0);
 }
 
-int getopt_long (int argc, char *const *argv, const char *options, 
-	const struct option *long_options, int *opt_index)
+int
+getopt_long (int argc, char *const *argv, const char *options,
+	     const struct option *long_options, int *opt_index)
 {
-    return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
 }
 
 /* Like getopt_long, but '-' as well as '--' can indicate a long option.
@@ -809,9 +1194,11 @@ int getopt_long (int argc, char *const *argv, const char *options,
    but does match a short option, it is parsed as a short option
    instead.  */
 
-int getopt_long_only (int argc, char *const *argv, const char *options, 
-	const struct option *long_options, int *opt_index)
+int
+getopt_long_only (int argc, char *const *argv, const char *options,
+		  const struct option *long_options, int *opt_index)
 {
-    return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
+  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
 }
 
+#endif	/* Not ELIDE_CODE.  */