Update.

2004-03-08  Paul Eggert  <eggert@cs.ucla.edu>

	Merge from gnulib.  We now assume C89 or better.
	* posix/getopt1.c (const): Remove.
	* posix/getopt.c (const): Likewise.
	* posix/getopt1.c (getopt_long, _getopt_long_r, getopt_long_only,
	_getopt_long_only_r, main): Use prototypes, not old-style definitions.
	* posix/getopt.c (exchange, _getopt_initialize, _getopt_internal_r,
	_getopt_internal, getopt, main): Likewise.
	* posix/getopt.h (getopt, getopt_long, getopt_long_only): Likewise.
	* posix/getopt.c [!defined VMS || !HAVE_STRING_H]:
	Include <string.h> regardless.  No need for <strings.h>.
	[!defined _LIBC]: Include "gettext.h" rather than rolling it ourselves.
	(_): Define to gettext always.
	(my_index): Remove: all uses changed to strchr.
	(strlen): Remove declaration.
	* posix/getopt.h (struct option.name): Always const char *.

2004-03-08  Marcus Brinkmann  <marcus@gnu.org>

	* posix/getopt.h (_getopt_internal): Move to ...
	* posix/getopt_int.h: ... here.  New file.
	* include/getopt_int.h: New file.
	* include/getopt.h: Remove libc_hidden_proto for getopt_long
	and getopt_long_only.
	* posix/getopt1.c: Include "getopt_int.h".  Remove
	libc_hidden_def for getopt_long and getopt_long_only.
	(_getopt_long_r, _getopt_long_only_r): New functions.
	* posix/getopt.c: Include "getopt_int.h".
	(__getopt_initialized): Variable removed.
	(nextchar, ordering, posixly_correct, first_nonopt, last_nonopt):
	Static variables removed.
	(nonoption_flags_max_len, nonoption_flags_len) [_LIBC &&
	USE_NONOPTION_FLAGS]: Static variables removed.
	(getopt_data): New static variable.
	(SWAP_FLAGS): Use d->__nonoption_flags_len instead
	nonoption_flags_len.
	(exchange): Add new argument D of type struct getopt_data *.
	Replace optind with d->optind, optarg with d->optarg, opterr with
	d->opterr, optopt with d->optopt, nextchar with d->__nextchar,
	first_nonopt with d->__first_nonopt, last_nonopt with
	d->__last_nonopt, d->ordering with d->__ordering,
	d->posixly_correct with d->__posixly_correct (which is now an
	int instead a string, so fix users), nonoption_flags_len
	with d->__nonoption_flags_len, nonoption_flags_max_len with
	d->__nonoption_flags_max_len.
	(_getopt_initialize): Likewise.
	(_getopt_internal): Rename to ...
	(_getopt_internal_r): ... this.  Also add new argument D of type
	struct getopt_data * and use of members of D rather than global or
	static variables as described for exchange() above.  Add new argument
	to invocations of _getopt_initialize and exchange.
	(_getopt_internal): Reimplement in terms of _getopt_internal_r.
	* argp/argp-parse.c: Include <getopt_int.h>.
	[_LIBC]: Do not include <bits/libc-lock.h>.
	[!_LIBC && HAVE_CTHREADS_H]: Do not include <cthreads.h>.
	[!_LIBC] (_argp_hang): Make static.
	(getopt_lock, LOCK_GETOPT, UNLOCK_GETOPT): Remove.
	(_argp_unlock_xxx): Remove.
	(parser_init): Do not use LOCK_GETOPT.
	(parser_finalize): Do not use UNLOCK_GETOPT.
	(struct parser): New member OPT_DATA.
	(parser_init): Initialize parser->opt_data.  Use
	parser->opt_data.opterr instead of opterr.
	(parser_parse_opt): Use parser->opt_data.optarg instead optarg.
	(parser_parse_next): Likewise.  Use parser->opt_data.optind
	instead optind.  Use parser->opt_data.optopt instead of optopt.
	Call _getopt_long_only_r and _getopt_long_r instead of
	getopt_long_only and getopt_long, and pass the extra argument.

1 files changed, 30 insertions, 72 deletions

diff --git a/argp/argp-parse.c b/argp/argp-parse.c
index 47223dc597..4718ced81d 100644
--- a/argp/argp-parse.c
+++ b/argp/argp-parse.c
@@ -1,5 +1,5 @@
 /* Hierarchial argument parsing, layered over getopt
-   Copyright (C) 1995-2000, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 1995-2000, 2002, 2003, 2004 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Written by Miles Bader <miles@gnu.ai.mit.edu>.
 
@@ -42,6 +42,7 @@ char *alloca ();
 #include <unistd.h>
 #include <limits.h>
 #include <getopt.h>
+#include <getopt_int.h>
 
 #ifndef _
 /* This is for other GNU distributions with internationalized messages.
@@ -62,14 +63,6 @@ char *alloca ();
 # define N_(msgid) (msgid)
 #endif
 
-#if _LIBC - 0
-#include <bits/libc-lock.h>
-#else
-#ifdef HAVE_CTHREADS_H
-#include <cthreads.h>
-#endif
-#endif /* _LIBC */
-
 #include "argp.h"
 #include "argp-namefrob.h"
 
@@ -97,14 +90,8 @@ char *alloca ();
 /* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
    for one second intervals, decrementing _ARGP_HANG until it's zero.  Thus
    you can force the program to continue by attaching a debugger and setting
-   it to 0 yourself.
-
-   XXX This variable used to be exported.  But there seems to be no
-   need, at least not inside libc.  */
-#ifdef _LIBC
-static
-#endif
-volatile int _argp_hang;
+   it to 0 yourself.  */
+static volatile int _argp_hang;
 
 #define OPT_PROGNAME	-2
 #define OPT_USAGE	-3
@@ -223,42 +210,7 @@ find_long_option (struct option *long_options, const char *name)
   else
     return -1;
 }
-
-/* If we can, we regulate access to getopt, which is non-reentrant, with a
-   mutex.  Since the case we're trying to guard against is two different
-   threads interfering, and it's possible that someone might want to call
-   argp_parse recursively (they're careful), we use a recursive lock if
-   possible.  */
-
-#if _LIBC - 0
-
-__libc_lock_define_initialized_recursive (static, getopt_lock)
-#define LOCK_GETOPT   __libc_lock_lock_recursive (getopt_lock)
-#define UNLOCK_GETOPT __libc_lock_unlock_recursive (getopt_lock)
-
-#else /* !_LIBC */
-#ifdef HAVE_CTHREADS_H
 
-static struct mutex getopt_lock = MUTEX_INITIALIZER;
-#define LOCK_GETOPT   mutex_lock (&getopt_lock)
-#define UNLOCK_GETOPT mutex_unlock (&getopt_lock)
-
-#else /* !HAVE_CTHREADS_H */
-
-#define LOCK_GETOPT    (void)0
-#define UNLOCK_GETOPT  (void)0
-
-#endif /* HAVE_CTHREADS_H */
-#endif /* _LIBC */
-
-/* This hack to allow programs that know what's going on to call argp
-   recursively.  If someday argp is changed not to use the non-reentrant
-   getopt interface, we can get rid of this shit.  XXX */
-void
-_argp_unlock_xxx (void)
-{
-  UNLOCK_GETOPT;
-}
 
 /* The state of a `group' during parsing.  Each group corresponds to a
    particular argp structure from the tree of such descending from the top
@@ -320,6 +272,8 @@ struct parser
   /* LONG_OPTS is the array of getop long option structures for the union of
      all the groups of options.  */
   struct option *long_opts;
+  /* OPT_DATA is the getopt data used for the re-entrant getopt.  */
+  struct _getopt_data opt_data;
 
   /* States of the various parsing groups.  */
   struct group *groups;
@@ -531,6 +485,7 @@ parser_init (struct parser *parser, const struct argp *argp,
   error_t err = 0;
   struct group *group;
   struct parser_sizes szs;
+  struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
 
   szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
   szs.long_len = 0;
@@ -554,6 +509,7 @@ parser_init (struct parser *parser, const struct argp *argp,
   parser->child_inputs = parser->storage + GLEN;
   parser->long_opts = parser->storage + GLEN + CLEN;
   parser->short_opts = parser->storage + GLEN + CLEN + LLEN;
+  parser->opt_data = opt_data;
 
   memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
   parser_convert (parser, argp, flags);
@@ -597,19 +553,16 @@ parser_init (struct parser *parser, const struct argp *argp,
   if (err)
     return err;
 
-  /* Getopt is (currently) non-reentrant.  */
-  LOCK_GETOPT;
-
   if (parser->state.flags & ARGP_NO_ERRS)
     {
-      opterr = 0;
+      parser->opt_data.opterr = 0;
       if (parser->state.flags & ARGP_PARSE_ARGV0)
 	/* getopt always skips ARGV[0], so we have to fake it out.  As long
 	   as OPTERR is 0, then it shouldn't actually try to access it.  */
 	parser->state.argv--, parser->state.argc++;
     }
   else
-    opterr = 1;		/* Print error messages.  */
+    parser->opt_data.opterr = 1;	/* Print error messages.  */
 
   if (parser->state.argv == argv && argv[0])
     /* There's an argv[0]; use it for messages.  */
@@ -630,8 +583,6 @@ parser_finalize (struct parser *parser,
 {
   struct group *group;
 
-  UNLOCK_GETOPT;
-
   if (err == EBADKEY && arg_ebadkey)
     /* Suppress errors generated by unparsed arguments.  */
     err = 0;
@@ -793,7 +744,8 @@ parser_parse_opt (struct parser *parser, int opt, char *val)
 	for (group = parser->groups; group < parser->egroup; group++)
 	  if (group->short_end > short_index)
 	    {
-	      err = group_parse (group, &parser->state, opt, optarg);
+	      err = group_parse (group, &parser->state, opt,
+				 parser->opt_data.optarg);
 	      break;
 	    }
     }
@@ -802,7 +754,8 @@ parser_parse_opt (struct parser *parser, int opt, char *val)
        the user value in order to preserve the sign.  */
     err =
       group_parse (&parser->groups[group_key - 1], &parser->state,
-		   (opt << GROUP_BITS) >> GROUP_BITS, optarg);
+		   (opt << GROUP_BITS) >> GROUP_BITS,
+		   parser->opt_data.optarg);
 
   if (err == EBADKEY)
     /* At least currently, an option not recognized is an error in the
@@ -848,15 +801,20 @@ parser_parse_next (struct parser *parser, int *arg_ebadkey)
   if (parser->try_getopt && !parser->state.quoted)
     /* Give getopt a chance to parse this.  */
     {
-      optind = parser->state.next; /* Put it back in OPTIND for getopt.  */
-      optopt = KEY_END;	/* Distinguish KEY_ERR from a real option.  */
+      /* Put it back in OPTIND for getopt.  */
+      parser->opt_data.optind = parser->state.next;
+      /* Distinguish KEY_ERR from a real option.  */
+      parser->opt_data.optopt = KEY_END;
       if (parser->state.flags & ARGP_LONG_ONLY)
-	opt = getopt_long_only (parser->state.argc, parser->state.argv,
-				parser->short_opts, parser->long_opts, 0);
+	opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
+				   parser->short_opts, parser->long_opts, 0,
+				   &parser->opt_data);
       else
-	opt = getopt_long (parser->state.argc, parser->state.argv,
-			   parser->short_opts, parser->long_opts, 0);
-      parser->state.next = optind; /* And see what getopt did.  */
+	opt = _getopt_long_r (parser->state.argc, parser->state.argv,
+			      parser->short_opts, parser->long_opts, 0,
+			      &parser->opt_data);
+      /* And see what getopt did.  */
+      parser->state.next = parser->opt_data.optind;
 
       if (opt == KEY_END)
 	/* Getopt says there are no more options, so stop using
@@ -872,7 +830,7 @@ parser_parse_next (struct parser *parser, int *arg_ebadkey)
 	       here, whatever happens.  */
 	    parser->state.quoted = parser->state.next;
 	}
-      else if (opt == KEY_ERR && optopt != KEY_END)
+      else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
 	/* KEY_ERR can have the same value as a valid user short
 	   option, but in the case of a real error, getopt sets OPTOPT
 	   to the offending character, which can never be KEY_END.  */
@@ -898,15 +856,15 @@ parser_parse_next (struct parser *parser, int *arg_ebadkey)
 	/* A non-option arg; simulate what getopt might have done.  */
 	{
 	  opt = KEY_ARG;
-	  optarg = parser->state.argv[parser->state.next++];
+	  parser->opt_data.optarg = parser->state.argv[parser->state.next++];
 	}
     }
 
   if (opt == KEY_ARG)
     /* A non-option argument; try each parser in turn.  */
-    err = parser_parse_arg (parser, optarg);
+    err = parser_parse_arg (parser, parser->opt_data.optarg);
   else
-    err = parser_parse_opt (parser, opt, optarg);
+    err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
 
   if (err == EBADKEY)
     *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);