(getargs) [MSDOS]: Don't assume optarg != NULL

[bison.git] / lib / argmatch.h

diff --git a/lib/argmatch.h b/lib/argmatch.h
index eb91f51aab106da32d76bf180bf161775488603d..deb908fb9d1b03427caa9805a5379a52985d6670 100644 (file)
--- a/lib/argmatch.h
+++ b/lib/argmatch.h
@@ -21,29 +21,24 @@
 #ifndef ARGMATCH_H_
 # define ARGMATCH_H_ 1
 
-# if HAVE_CONFIG_H
-#  include <config.h>
-# endif
+# include <stddef.h>
 
-# include <sys/types.h>
+# define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
 
-# ifndef PARAMS
-#  if PROTOTYPES || (defined (__STDC__) && __STDC__)
-#   define PARAMS(args) args
-#  else
-#   define PARAMS(args) ()
-#  endif  /* GCC.  */
-# endif  /* Not PARAMS.  */
+# define ARGMATCH_CONSTRAINT(Arglist, Vallist) \
+  (ARRAY_CARDINALITY (Arglist) == ARRAY_CARDINALITY (Vallist) + 1)
 
 /* Assert there are as many real arguments as there are values
-   (argument list ends with a NULL guard).  There is no execution
-   cost, since it will be statically evalauted to `assert (0)' or
-   `assert (1)'.  Unfortunately there is no -Wassert-0. */
+   (argument list ends with a NULL guard).  ARGMATCH_VERIFY is
+   preferred, since it is guaranteed to be checked at compile-time.
+   ARGMATCH_ASSERT is for backward compatibility only.  */
 
-# define ARRAY_CARDINALITY(Array) (sizeof ((Array)) / sizeof (*(Array)))
+# define ARGMATCH_VERIFY(Arglist, Vallist)                               \
+  struct argmatch_verify                                                 \
+  {                                                                      \
+    char argmatch_verify[ARGMATCH_CONSTRAINT(Arglist, Vallist) ? 1 : -1]; \
+  }
 
-# define ARGMATCH_CONSTRAINT(Arglist, Vallist) \
-  (ARRAY_CARDINALITY ((Arglist)) == ARRAY_CARDINALITY ((Vallist)) + 1)
 # define ARGMATCH_ASSERT(Arglist, Vallist) \
   assert (ARGMATCH_CONSTRAINT (Arglist, Vallist))
 
@@ -52,79 +47,63 @@
    false ambiguities (i.e., different matches of ARG but corresponding
    to the same values in VALLIST).  */
 
-int argmatch
-  PARAMS ((const char *arg, const char *const *arglist,
-          const char *vallist, size_t valsize));
-int argcasematch
-  PARAMS ((const char *arg, const char *const *arglist,
-          const char *vallist, size_t valsize));
+int argmatch (char const *arg, char const *const *arglist,
+             char const *vallist, size_t valsize);
 
 # define ARGMATCH(Arg, Arglist, Vallist) \
-  argmatch ((Arg), (Arglist), (const char *) (Vallist), sizeof (*(Vallist)))
-
-# define ARGCASEMATCH(Arg, Arglist, Vallist) \
-  argcasematch ((Arg), (Arglist), (const char *) (Vallist), sizeof (*(Vallist)))
+  argmatch (Arg, Arglist, (char const *) (Vallist), sizeof *(Vallist))
 
 /* xargmatch calls this function when it fails.  This function should not
    return.  By default, this is a function that calls ARGMATCH_DIE which
    in turn defaults to `exit (EXIT_FAILURE)'.  */
-typedef void (*argmatch_exit_fn) PARAMS ((void));
+typedef void (*argmatch_exit_fn) (void);
 extern argmatch_exit_fn argmatch_die;
 
 /* Report on stderr why argmatch failed.  Report correct values. */
 
-void argmatch_invalid
-  PARAMS ((const char *context, const char *value, int problem));
+void argmatch_invalid (char const *context, char const *value, int problem);
 
 /* Left for compatibility with the old name invalid_arg */
 
 # define invalid_arg(Context, Value, Problem) \
-  argmatch_invalid ((Context), (Value), (Problem))
+  argmatch_invalid (Context, Value, Problem)
 
 
 
 /* Report on stderr the list of possible arguments.  */
 
-void argmatch_valid
-  PARAMS ((const char *const *arglist,
-          const char *vallist, size_t valsize));
+void argmatch_valid (char const *const *arglist,
+                    char const *vallist, size_t valsize);
 
 # define ARGMATCH_VALID(Arglist, Vallist) \
-  argmatch_valid (Arglist, (const char *) Vallist, sizeof (*(Vallist)))
+  argmatch_valid (Arglist, (char const *) (Vallist), sizeof *(Vallist))
 
 
 
 /* Same as argmatch, but upon failure, reports a explanation on the
    failure, and exits using the function EXIT_FN. */
 
-int __xargmatch_internal
-  PARAMS ((const char *context,
-          const char *arg, const char *const *arglist,
-          const char *vallist, size_t valsize,
-          int case_sensitive, argmatch_exit_fn exit_fn));
+int __xargmatch_internal (char const *context,
+                         char const *arg, char const *const *arglist,
+                         char const *vallist, size_t valsize,
+                         argmatch_exit_fn exit_fn);
 
 /* Programmer friendly interface to __xargmatch_internal. */
 
-# define XARGMATCH(Context, Arg, Arglist, Vallist)                     \
-  (Vallist [__xargmatch_internal ((Context), (Arg), (Arglist), \
-                                  (const char *) (Vallist),    \
-                                 sizeof (*(Vallist)),          \
-                                 1, argmatch_die)])
-
-# define XARGCASEMATCH(Context, Arg, Arglist, Vallist)         \
-  (Vallist [__xargmatch_internal ((Context), (Arg), (Arglist), \
-                                  (const char *) (Vallist),    \
-                                 sizeof (*(Vallist)),          \
-                                 0, argmatch_die)])
+# define XARGMATCH(Context, Arg, Arglist, Vallist)             \
+  ((Vallist) [__xargmatch_internal (Context, Arg, Arglist,     \
+                                   (char const *) (Vallist),   \
+                                   sizeof *(Vallist),          \
+                                   argmatch_die)])
 
 /* Convert a value into a corresponding argument. */
 
-const char *argmatch_to_argument
-  PARAMS ((char const *value, const char *const *arglist,
-          const char *vallist, size_t valsize));
+char const *argmatch_to_argument (char const *value,
+                                 char const *const *arglist,
+                                 char const *vallist, size_t valsize);
 
 # define ARGMATCH_TO_ARGUMENT(Value, Arglist, Vallist)                 \
-  argmatch_to_argument ((Value), (Arglist),            \
-                       (const char *) (Vallist), sizeof (*(Vallist)))
+  argmatch_to_argument (Value, Arglist,                                        \
+                       (char const *) (Vallist), sizeof *(Vallist))
 
 #endif /* ARGMATCH_H_ */