xemacs-beta: lib-src/getopt.c comparison

comparison lib-src/getopt.c @ 155:43dd3413c7c7 r20-3b4

Import from CVS: tag r20-3b4

author	cvs
date	Mon, 13 Aug 2007 09:39:39 +0200
parents	131b0175ea99
children	15872534500d

comparison

equal deleted inserted replaced

-:94141801dd7e
+:43dd3413c7c7
 /* Getopt for GNU.
 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 roland@gnu.ai.mit.edu
 before changing it!
-Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95
+Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
 	Free Software Foundation, Inc.
-This program is free software; you can redistribute it and/or modify it
+NOTE: The canonical source of this file is maintained with the GNU C Library.
-under the terms of the GNU General Public License as published by the
+Bugs can be reported to bug-glibc@prep.ai.mit.edu.
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
-This program is distributed in the hope that it will be useful,
+Free Software Foundation; either version 2, or (at your option) any
-but WITHOUT ANY WARRANTY; without even the implied warranty of
+later version.
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-You should have received a copy of the GNU General Public License
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-along with this program; see the file COPYING.  If not, write to
+GNU General Public License for more details.
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
-/* Synched up with: FSF 19.28. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+USA.  */
 /* 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
-#if defined (emacs) || defined (CONFIG_BROKETS)
-/* We use <config.h> instead of "config.h" so that a compilation
-using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
-(which it would do because it found this file in $srcdir).  */
 #include <config.h>
-#else
-#include "config.h"
-#endif
 #endif
 #if !defined (__STDC__) || !__STDC__
 /* This is a separate conditional since some stdc systems
 reject `defined (const)'.  */
 #define const
 #endif
 #endif
 #include <stdio.h>
+#ifdef STDC_HEADERS
+#include <string.h>
 #include <stdlib.h>
-#include <string.h>
+#endif
 /* 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.  */
-#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
+#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.  */
+#ifdef VMS
+#include <unixlib.h>
+#if HAVE_STRING_H - 0
+#include <string.h>
+#endif
+#endif
+#if defined (WIN32) && !defined (__CYGWIN32__)
+/* It's not Unix, really.  See?  Capital letters.  */
+#include <windows.h>
+#define getpid() GetCurrentProcessId()
+#endif
+#ifndef _
 /* This is for other GNU distributions with internationalized messages.
-The GNU C Library itself does not yet support such messages.  */
+When compiling libc, the _ macro is predefined.  */
-#if defined (I18N3) && defined (HAVE_LIBINTL_H)
+#ifdef HAVE_LIBINTL_H
 # include <libintl.h>
+# define _(msgid)	gettext (msgid)
 #else
-# define gettext(msgid) (msgid)
+# define _(msgid)	(msgid)
+#endif
 #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.
 This is used for communication to and from the caller
 and for communication between successive calls to `getopt'.
 On entry to `getopt', zero means this is the first call; initialize.
-When `getopt' returns EOF, this is the index of the first of the
+When `getopt' returns -1, this is the index of the first of the
 non-option elements that the caller should itself scan.
 Otherwise, `optind' communicates from one call to the next
 how much of ARGV has been scanned so far.  */
-/* XXX 1003.2 says this must be 1 before any call.  */
+/* 1003.2 says this must be 1 before any call.  */
-int optind = 0;
+int optind = 1;
+/* Formerly, initialization of getopt depended on optind==0, which
+causes problems with re-calling getopt as programs generally don't
+know that. */
+int __getopt_initialized = 0;
 /* 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.
 Using `-' as the first character of the list of option characters
 selects this mode of operation.
 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 EOF with `optind' != ARGC.  */
+`--' can cause `getopt' to return -1 with `optind' != ARGC.  */
 static enum
 {
 REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
 } ordering;
 whose names are inconsistent.  */
 char *getenv ();
 static char *
-my_index (str, chr)
+my_index (const char *str, int chr)
-const char *str;
-int chr;
 {
 while (*str)
 {
 if (*str == chr)
 	return (char *) str;
 `last_nonopt' is the index after the last of them.  */
 static int first_nonopt;
 static int last_nonopt;
+#ifdef _LIBC
+/* 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;
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+static int original_argc;
+static char *const *original_argv;
+extern pid_t __libc_pid;
+/* Make sure the environment variable bash 2.0 puts in the environment
+is valid for the getopt call we must make sure that the ARGV passed
+to getopt is that one passed to the process.  */
+static void
+__attribute__ ((unused))
+store_args_and_env (int argc, char *const *argv)
+{
+/* 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).  */
+original_argc = argc;
+original_argv = argv;
+}
+text_set_element (__libc_subinit, store_args_and_env);
+# define SWAP_FLAGS(ch1, ch2) \
+if (nonoption_flags_len > 0)						      \
+{									      \
+char __tmp = __getopt_nonoption_flags[ch1];			      \
+__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
+__getopt_nonoption_flags[ch2] = __tmp;				      \
+}
+#else	/* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif	/* _LIBC */
 /* Exchange two adjacent subsequences of ARGV.
 One subsequence is elements [first_nonopt,last_nonopt)
 which contains all the non-options that have been skipped so far.
 The other is elements [last_nonopt,optind), which contains all
 the options processed since those non-options were skipped.
 `first_nonopt' and `last_nonopt' are relocated so that they describe
 the new indices of the non-options in ARGV after they are moved.  */
+#if defined (__STDC__) && __STDC__
+static void exchange (char **);
+#endif
 static void
-exchange (argv)
+exchange (char **argv)
-char **argv;
 {
 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.  */
+#ifdef _LIBC
+/* 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 (nonoption_flags_len > 0 && top >= 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)
+	nonoption_flags_len = nonoption_flags_max_len = 0;
+else
+	{
+	  memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
+	  memset (&new_str[nonoption_flags_max_len], '\0',
+		  top + 1 - nonoption_flags_max_len);
+	  nonoption_flags_max_len = top + 1;
+	  __getopt_nonoption_flags = new_str;
+	}
+}
+#endif
 while (top > middle && middle > bottom)
 {
 if (top - middle > middle - bottom)
 	{
 	  for (i = 0; i < len; i++)
 	    {
 	      tem = argv[bottom + i];
 	      argv[bottom + i] = argv[top - (middle - bottom) + i];
 	      argv[top - (middle - bottom) + i] = tem;
+	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
 	    }
 	  /* Exclude the moved bottom segment from further swapping.  */
 	  top -= len;
 	}
 else
 	  for (i = 0; i < len; i++)
 	    {
 	      tem = argv[bottom + i];
 	      argv[bottom + i] = argv[middle + i];
 	      argv[middle + i] = tem;
+	      SWAP_FLAGS (bottom + i, middle + i);
 	    }
 	  /* Exclude the moved top segment from further swapping.  */
 	  bottom += len;
 	}
 }
 last_nonopt = optind;
 }
 /* Initialize the internal data when the first call is made.  */
+#if defined (__STDC__) && __STDC__
+static const char *_getopt_initialize (int, char *const *, const char *);
+#endif
 static const char *
-_getopt_initialize (optstring)
+_getopt_initialize (int argc, char *const *argv, const char *optstring)
-const char *optstring;
 {
 /* 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.  */
-first_nonopt = last_nonopt = optind = 1;
+first_nonopt = last_nonopt = optind;
 nextchar = NULL;
 posixly_correct = getenv ("POSIXLY_CORRECT");
 }
 else if (posixly_correct != NULL)
 ordering = REQUIRE_ORDER;
 else
 ordering = PERMUTE;
+#ifdef _LIBC
+if (posixly_correct == NULL
+&& argc == original_argc && argv == original_argv)
+{
+if (nonoption_flags_max_len == 0)
+	{
+	  if (__getopt_nonoption_flags == NULL
+	      || __getopt_nonoption_flags[0] == '\0')
+	    nonoption_flags_max_len = -1;
+	  else
+	    {
+	      const char *orig_str = __getopt_nonoption_flags;
+	      int len = nonoption_flags_max_len = strlen (orig_str);
+	      if (nonoption_flags_max_len < argc)
+		nonoption_flags_max_len = argc;
+	      __getopt_nonoption_flags =
+		(char *) malloc (nonoption_flags_max_len);
+	      if (__getopt_nonoption_flags == NULL)
+		nonoption_flags_max_len = -1;
+	      else
+		{
+		  memcpy (__getopt_nonoption_flags, orig_str, len);
+		  memset (&__getopt_nonoption_flags[len], '\0',
+			  nonoption_flags_max_len - len);
+		}
+	    }
+	}
+nonoption_flags_len = nonoption_flags_max_len;
+}
+else
+nonoption_flags_len = 0;
+#endif
 return optstring;
 }
 /* Scan elements of ARGV (whose length is ARGC) for option characters
 If `getopt' finds another option character, it returns that character,
 updating `optind' and `nextchar' so that the next call to `getopt' can
 resume the scan with the following option character or ARGV-element.
-If there are no more option characters, `getopt' returns `EOF'.
+If there are no more option characters, `getopt' returns -1.
 Then `optind' is the index in ARGV of the first ARGV-element
 that is not an option.  (The ARGV-elements have been permuted
 so that those that are not options now come last.)
 OPTSTRING is a string containing the legitimate option characters.
 If LONG_ONLY is nonzero, '-' as well as '--' can introduce
 long-named options.  */
 int
-_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+_getopt_internal (int argc, char *const *argv, const char *optstring,
-int argc;
+		  const struct option *longopts, int *longind, int long_only)
-char *const *argv;
-const char *optstring;
-const struct option *longopts;
-int *longind;
-int long_only;
 {
 optarg = NULL;
-if (optind == 0)
+if (optind == 0 || !__getopt_initialized)
 {
-optstring = _getopt_initialize (optstring);
+if (optind == 0)
-optind = 1;		/* Don't scan ARGV[0], the program name.  */
+	optind = 1;	/* Don't scan ARGV[0], the program name.  */
-}
+optstring = _getopt_initialize (argc, argv, optstring);
+__getopt_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.  */
+#ifdef _LIBC
+#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
+		     || (optind < nonoption_flags_len			      \
+			 && __getopt_nonoption_flags[optind] == '1'))
+#else
+#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
+#endif
 if (nextchar == NULL || *nextchar == '\0')
 {
 /* 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;
 if (ordering == PERMUTE)
 	{
 	  /* If we have just processed some options following some non-options,
 	     exchange them so that the options come first.  */
 	    first_nonopt = optind;
 	  /* Skip any additional non-options
 	     and extend the range of non-options previously skipped.  */
-	  while (optind < argc
+	  while (optind < argc && NONOPTION_P)
-		 && (argv[optind][0] != '-' || argv[optind][1] == '\0'))
 	    optind++;
 	  last_nonopt = optind;
 	}
 /* The special ARGV-element `--' means premature end of options.
 	{
 	  /* 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 EOF;
+	  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 ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
+if (NONOPTION_P)
 	{
 	  if (ordering == REQUIRE_ORDER)
-	    return EOF;
+	    return -1;
 	  optarg = argv[optind++];
 	  return 1;
 	}
 /* We have found another option-ARGV-element.
 char *nameend;
 const struct option *p;
 const struct option *pfound = NULL;
 int exact = 0;
 int ambig = 0;
-int indfound = 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))
 	  {
-	    if (nameend - nextchar == strlen (p->name))
+	    if ((unsigned int) (nameend - nextchar)
+		== (unsigned int) strlen (p->name))
 	      {
 		/* Exact match found.  */
 		pfound = p;
 		indfound = option_index;
 		exact = 1;
 	  }
 if (ambig && !exact)
 	{
 	  if (opterr)
-	    fprintf (stderr, gettext ("%s: option `%s' is ambiguous\n"),
+	    fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
 		     argv[0], argv[optind]);
 	  nextchar += strlen (nextchar);
 	  optind++;
+	  optopt = 0;
 	  return '?';
 	}
 if (pfound != NULL)
 	{
 		{
 		  if (opterr)
 		   if (argv[optind - 1][1] == '-')
 		    /* --option */
 		    fprintf (stderr,
-		     gettext ("%s: option `--%s' doesn't allow an argument\n"),
+		     _("%s: option `--%s' doesn't allow an argument\n"),
 		     argv[0], pfound->name);
 		   else
 		    /* +option or -option */
 		    fprintf (stderr,
-		     gettext ("%s: option `%c%s' doesn't allow an argument\n"),
+		     _("%s: option `%c%s' doesn't allow an argument\n"),
 		     argv[0], argv[optind - 1][0], pfound->name);
 		  nextchar += strlen (nextchar);
+		  optopt = pfound->val;
 		  return '?';
 		}
 	    }
 	  else if (pfound->has_arg == 1)
 	    {
 		optarg = argv[optind++];
 	      else
 		{
 		  if (opterr)
 		    fprintf (stderr,
-			   gettext ("%s: option `%s' requires an argument\n"),
+			   _("%s: option `%s' requires an argument\n"),
 			   argv[0], argv[optind - 1]);
 		  nextchar += strlen (nextchar);
+		  optopt = pfound->val;
 		  return optstring[0] == ':' ? ':' : '?';
 		}
 	    }
 	  nextchar += strlen (nextchar);
 	  if (longind != NULL)
 	{
 	  if (opterr)
 	    {
 	      if (argv[optind][1] == '-')
 		/* --option */
-		fprintf (stderr, gettext ("%s: unrecognized option `--%s'\n"),
+		fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
 			 argv[0], nextchar);
 	      else
 		/* +option or -option */
-		fprintf (stderr, gettext ("%s: unrecognized option `%c%s'\n"),
+		fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
 			 argv[0], argv[optind][0], nextchar);
 	    }
 	  nextchar = (char *) "";
 	  optind++;
+	  optopt = 0;
 	  return '?';
 	}
 }
 /* Look at and handle the next short option-character.  */
 {
 	if (opterr)
 	  {
 	    if (posixly_correct)
 	      /* 1003.2 specifies the format of this message.  */
-	      fprintf (stderr, gettext ("%s: illegal option -- %c\n"),
+	      fprintf (stderr, _("%s: illegal option -- %c\n"),
 		       argv[0], c);
 	    else
-	      fprintf (stderr, gettext ("%s: invalid option -- %c\n"),
+	      fprintf (stderr, _("%s: invalid option -- %c\n"),
 		       argv[0], c);
 	  }
 	optopt = c;
 	return '?';
+}
+/* Convenience. Treat POSIX -W foo same as long option --foo */
+if (temp[0] == 'W' && temp[1] == ';')
+{
+	char *nameend;
+	const struct option *p;
+	const struct option *pfound = NULL;
+	int exact = 0;
+	int ambig = 0;
+	int indfound = 0;
+	int option_index;
+	/* This is an option that requires an argument.  */
+	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 (opterr)
+	      {
+		/* 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;
+	  }
+	else
+	  /* We already incremented `optind' once;
+	     increment it again when taking next ARGV-elt as argument.  */
+	  optarg = argv[optind++];
+	/* optarg is now the argument, see if it's in the
+	   table of longopts.  */
+	for (nextchar = nameend = 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 (opterr)
+	      fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+		       argv[0], argv[optind]);
+	    nextchar += strlen (nextchar);
+	    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)
+		  optarg = nameend + 1;
+		else
+		  {
+		    if (opterr)
+		      fprintf (stderr, _("\
+%s: option `-W %s' doesn't allow an argument\n"),
+			       argv[0], pfound->name);
+		    nextchar += strlen (nextchar);
+		    return '?';
+		  }
+	      }
+	    else if (pfound->has_arg == 1)
+	      {
+		if (optind < argc)
+		  optarg = argv[optind++];
+		else
+		  {
+		    if (opterr)
+		      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;
+	      }
+	    return pfound->val;
+	  }
+	  nextchar = NULL;
+	  return 'W';	/* Let the application handle it.   */
 }
 if (temp[1] == ':')
 {
 	if (temp[2] == ':')
 	  {
 	      {
 		if (opterr)
 		  {
 		    /* 1003.2 specifies the format of this message.  */
 		    fprintf (stderr,
-			   gettext ("%s: option requires an argument -- %c\n"),
+			   _("%s: option requires an argument -- %c\n"),
 			   argv[0], c);
 		  }
 		optopt = c;
 		if (optstring[0] == ':')
 		  c = ':';
 return c;
 }
 }
 int
-getopt (argc, argv, optstring)
+getopt (int argc, char *const *argv, const char *optstring)
-int argc;
-char *const *argv;
-const char *optstring;
 {
 return _getopt_internal (argc, argv, optstring,
 			   (const struct option *) 0,
 			   (int *) 0,
 			   0);
 }
-#endif	/* _LIBC or not __GNU_LIBRARY__.  */
+#endif	/* Not ELIDE_CODE.  */
 #ifdef TEST
 /* Compile with -DTEST to make an executable for use in testing
 the above definition of `getopt'.  */
 int
-main (argc, argv)
+main (int argc, char **argv)
-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 == EOF)
+if (c == -1)
 	break;
 switch (c)
 	{
 	case '0':

Mercurial > hg > xemacs-beta

comparison lib-src/getopt.c @ 155:43dd3413c7c7 r20-3b4