merge from gcc

3 files changed, 90 insertions, 86 deletions

diff --git a/include/ChangeLog b/include/ChangeLog
index 6f64e06..04b7e46 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,3 +1,11 @@
+2005-03-26  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	* demangle.h: Remove uses of PARAMS.
+
+	* libiberty.h (ANSI_PROTOTYPES): Remove guard since
+	ANSI_PROTOTYPES is always assumed.
+	Remove uses of PARAMS throughout.
+
 2005-03-24  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
 	* libiberty.h (xstrndup): Declare.
diff --git a/include/demangle.h b/include/demangle.h
index b3b8c58..b88b43d 100644
--- a/include/demangle.h
+++ b/include/demangle.h
@@ -110,31 +110,31 @@ extern const struct demangler_engine
 } libiberty_demanglers[];
 
 extern char *
-cplus_demangle PARAMS ((const char *mangled, int options));
+cplus_demangle (const char *mangled, int options);
 
 extern int
-cplus_demangle_opname PARAMS ((const char *opname, char *result, int options));
+cplus_demangle_opname (const char *opname, char *result, int options);
 
 extern const char *
-cplus_mangle_opname PARAMS ((const char *opname, int options));
+cplus_mangle_opname (const char *opname, int options);
 
 /* Note: This sets global state.  FIXME if you care about multi-threading. */
 
 extern void
-set_cplus_marker_for_demangling PARAMS ((int ch));
+set_cplus_marker_for_demangling (int ch);
 
 extern enum demangling_styles 
-cplus_demangle_set_style PARAMS ((enum demangling_styles style));
+cplus_demangle_set_style (enum demangling_styles style);
 
 extern enum demangling_styles 
-cplus_demangle_name_to_style PARAMS ((const char *name));
+cplus_demangle_name_to_style (const char *name);
 
 /* V3 ABI demangling entry points, defined in cp-demangle.c.  */
 extern char*
-cplus_demangle_v3 PARAMS ((const char* mangled, int options));
+cplus_demangle_v3 (const char* mangled, int options);
 
 extern char*
-java_demangle_v3 PARAMS ((const char* mangled));
+java_demangle_v3 (const char* mangled);
 
 
 enum gnu_v3_ctor_kinds {
@@ -148,7 +148,7 @@ enum gnu_v3_ctor_kinds {
    gnu_v3_ctor_kinds' value indicating what kind of constructor
    it is.  */
 extern enum gnu_v3_ctor_kinds
-	is_gnu_v3_mangled_ctor PARAMS ((const char *name));
+	is_gnu_v3_mangled_ctor (const char *name);
 
 
 enum gnu_v3_dtor_kinds {
@@ -162,7 +162,7 @@ enum gnu_v3_dtor_kinds {
    gnu_v3_dtor_kinds' value, indicating what kind of destructor
    it is.  */
 extern enum gnu_v3_dtor_kinds
-	is_gnu_v3_mangled_dtor PARAMS ((const char *name));
+	is_gnu_v3_mangled_dtor (const char *name);
 
 /* The V3 demangler works in two passes.  The first pass builds a tree
    representation of the mangled name, and the second pass turns the
@@ -440,25 +440,25 @@ struct demangle_component
    unrecognized or inappropriate component type.  */
 
 extern int
-cplus_demangle_fill_component PARAMS ((struct demangle_component *fill,
-				       enum demangle_component_type,
-				       struct demangle_component *left,
-				       struct demangle_component *right));
+cplus_demangle_fill_component (struct demangle_component *fill,
+                               enum demangle_component_type,
+                               struct demangle_component *left,
+                               struct demangle_component *right);
 
 /* Fill in a DEMANGLE_COMPONENT_NAME.  Returns non-zero on success,
    zero for bad arguments.  */
 
 extern int
-cplus_demangle_fill_name PARAMS ((struct demangle_component *fill,
-				  const char *, int));
+cplus_demangle_fill_name (struct demangle_component *fill,
+                          const char *, int);
 
 /* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE, using the name of the
    builtin type (e.g., "int", etc.).  Returns non-zero on success,
    zero if the type is not recognized.  */
 
 extern int
-cplus_demangle_fill_builtin_type PARAMS ((struct demangle_component *fill,
-					  const char *type_name));
+cplus_demangle_fill_builtin_type (struct demangle_component *fill,
+                                  const char *type_name);
 
 /* Fill in a DEMANGLE_COMPONENT_OPERATOR, using the name of the
    operator and the number of arguments which it takes (the latter is
@@ -467,33 +467,33 @@ cplus_demangle_fill_builtin_type PARAMS ((struct demangle_component *fill,
    not recognized.  */
 
 extern int
-cplus_demangle_fill_operator PARAMS ((struct demangle_component *fill,
-				      const char *opname, int args));
+cplus_demangle_fill_operator (struct demangle_component *fill,
+                              const char *opname, int args);
 
 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR, providing the
    number of arguments and the name.  Returns non-zero on success,
    zero for bad arguments.  */
 
 extern int
-cplus_demangle_fill_extended_operator PARAMS ((struct demangle_component *fill,
-					       int numargs,
-					       struct demangle_component *nm));
+cplus_demangle_fill_extended_operator (struct demangle_component *fill,
+                                       int numargs,
+                                       struct demangle_component *nm);
 
 /* Fill in a DEMANGLE_COMPONENT_CTOR.  Returns non-zero on success,
    zero for bad arguments.  */
 
 extern int
-cplus_demangle_fill_ctor PARAMS ((struct demangle_component *fill,
-				  enum gnu_v3_ctor_kinds kind,
-				  struct demangle_component *name));
+cplus_demangle_fill_ctor (struct demangle_component *fill,
+                          enum gnu_v3_ctor_kinds kind,
+                          struct demangle_component *name);
 
 /* Fill in a DEMANGLE_COMPONENT_DTOR.  Returns non-zero on success,
    zero for bad arguments.  */
 
 extern int
-cplus_demangle_fill_dtor PARAMS ((struct demangle_component *fill,
-				  enum gnu_v3_dtor_kinds kind,
-				  struct demangle_component *name));
+cplus_demangle_fill_dtor (struct demangle_component *fill,
+                          enum gnu_v3_dtor_kinds kind,
+                          struct demangle_component *name);
 
 /* This function translates a mangled name into a struct
    demangle_component tree.  The first argument is the mangled name.
@@ -504,9 +504,7 @@ cplus_demangle_fill_dtor PARAMS ((struct demangle_component *fill,
    needed.  */
 
 extern struct demangle_component *
-cplus_demangle_v3_components PARAMS ((const char *mangled,
-				      int options,
-				      void **mem));
+cplus_demangle_v3_components (const char *mangled, int options, void **mem);
 
 /* This function takes a struct demangle_component tree and returns
    the corresponding demangled string.  The first argument is DMGL_*
@@ -521,10 +519,10 @@ cplus_demangle_v3_components PARAMS ((const char *mangled,
    memory allocation error.  */
 
 extern char *
-cplus_demangle_print PARAMS ((int options,
-			      const struct demangle_component *tree,
-			      int estimated_length,
-			      size_t *p_allocated_size));
+cplus_demangle_print (int options,
+                      const struct demangle_component *tree,
+                      int estimated_length,
+                      size_t *p_allocated_size);
 
 #ifdef __cplusplus
 }
diff --git a/include/libiberty.h b/include/libiberty.h
index 49a2fb6..a064210 100644
--- a/include/libiberty.h
+++ b/include/libiberty.h
@@ -41,26 +41,24 @@ extern "C" {
 
 #include "ansidecl.h"
 
-#ifdef ANSI_PROTOTYPES
 /* Get a definition for size_t.  */
 #include <stddef.h>
 /* Get a definition for va_list.  */
 #include <stdarg.h>
-#endif
 
 /* Build an argument vector from a string.  Allocates memory using
    malloc.  Use freeargv to free the vector.  */
 
-extern char **buildargv PARAMS ((const char *)) ATTRIBUTE_MALLOC;
+extern char **buildargv (const char *) ATTRIBUTE_MALLOC;
 
 /* Free a vector returned by buildargv.  */
 
-extern void freeargv PARAMS ((char **));
+extern void freeargv (char **);
 
 /* Duplicate an argument vector. Allocates memory using malloc.  Use
    freeargv to free the vector.  */
 
-extern char **dupargv PARAMS ((char **)) ATTRIBUTE_MALLOC;
+extern char **dupargv (char **) ATTRIBUTE_MALLOC;
 
 
 /* Return the last component of a path name.  Note that we can't use a
@@ -75,7 +73,7 @@ extern char **dupargv PARAMS ((char **)) ATTRIBUTE_MALLOC;
    is 1, we found it so don't provide any declaration at all.  */
 #if !HAVE_DECL_BASENAME
 #if defined (__GNU_LIBRARY__ ) || defined (__linux__) || defined (__FreeBSD__) || defined (__OpenBSD__) || defined(__NetBSD__) || defined (__CYGWIN__) || defined (__CYGWIN32__) || defined (__MINGW32__) || defined (HAVE_DECL_BASENAME)
-extern char *basename PARAMS ((const char *));
+extern char *basename (const char *);
 #else
 extern char *basename ();
 #endif
@@ -83,17 +81,17 @@ extern char *basename ();
 
 /* A well-defined basename () that is always compiled in.  */
 
-extern const char *lbasename PARAMS ((const char *));
+extern const char *lbasename (const char *);
 
 /* A well-defined realpath () that is always compiled in.  */
 
-extern char *lrealpath PARAMS ((const char *));
+extern char *lrealpath (const char *);
 
 /* Concatenate an arbitrary number of strings.  You must pass NULL as
    the last argument of this function, to terminate the list of
    strings.  Allocates memory using xmalloc.  */
 
-extern char *concat PARAMS ((const char *, ...)) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
+extern char *concat (const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
 
 /* Concatenate an arbitrary number of strings.  You must pass NULL as
    the last argument of this function, to terminate the list of
@@ -102,27 +100,27 @@ extern char *concat PARAMS ((const char *, ...)) ATTRIBUTE_MALLOC ATTRIBUTE_SENT
    pointer to be freed after the new string is created, similar to the
    way xrealloc works.  */
 
-extern char *reconcat PARAMS ((char *, const char *, ...)) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
+extern char *reconcat (char *, const char *, ...) ATTRIBUTE_MALLOC ATTRIBUTE_SENTINEL;
 
 /* Determine the length of concatenating an arbitrary number of
    strings.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  */
 
-extern unsigned long concat_length PARAMS ((const char *, ...)) ATTRIBUTE_SENTINEL;
+extern unsigned long concat_length (const char *, ...) ATTRIBUTE_SENTINEL;
 
 /* Concatenate an arbitrary number of strings into a SUPPLIED area of
    memory.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  The supplied memory is assumed
    to be large enough.  */
 
-extern char *concat_copy PARAMS ((char *, const char *, ...)) ATTRIBUTE_SENTINEL;
+extern char *concat_copy (char *, const char *, ...) ATTRIBUTE_SENTINEL;
 
 /* Concatenate an arbitrary number of strings into a GLOBAL area of
    memory.  You must pass NULL as the last argument of this function,
    to terminate the list of strings.  The supplied memory is assumed
    to be large enough.  */
 
-extern char *concat_copy2 PARAMS ((const char *, ...)) ATTRIBUTE_SENTINEL;
+extern char *concat_copy2 (const char *, ...) ATTRIBUTE_SENTINEL;
 
 /* This is the global area used by concat_copy2.  */
 
@@ -138,12 +136,12 @@ extern char *libiberty_concat_ptr;
 
 /* Check whether two file descriptors refer to the same file.  */
 
-extern int fdmatch PARAMS ((int fd1, int fd2));
+extern int fdmatch (int fd1, int fd2);
 
 /* Get the working directory.  The result is cached, so don't call
    chdir() between calls to getpwd().  */
 
-extern char * getpwd PARAMS ((void));
+extern char * getpwd (void);
 
 /* Get the current time.  */
 /* Prototypes vary from system to system, so we only provide a
@@ -151,121 +149,121 @@ extern char * getpwd PARAMS ((void));
 #ifdef __MINGW32__
 /* Forward declaration to avoid #include <sys/time.h>.   */
 struct timeval;
-extern int gettimeofday PARAMS ((struct timeval *, void *)); 
+extern int gettimeofday (struct timeval *, void *); 
 #endif
 
 /* Get the amount of time the process has run, in microseconds.  */
 
-extern long get_run_time PARAMS ((void));
+extern long get_run_time (void);
 
 /* Generate a relocated path to some installation directory.  Allocates
    return value using malloc.  */
 
-extern char *make_relative_prefix PARAMS ((const char *, const char *,
-					   const char *)) ATTRIBUTE_MALLOC;
+extern char *make_relative_prefix (const char *, const char *,
+                                   const char *) ATTRIBUTE_MALLOC;
 
 /* Choose a temporary directory to use for scratch files.  */
 
-extern char *choose_temp_base PARAMS ((void)) ATTRIBUTE_MALLOC;
+extern char *choose_temp_base (void) ATTRIBUTE_MALLOC;
 
 /* Return a temporary file name or NULL if unable to create one.  */
 
-extern char *make_temp_file PARAMS ((const char *)) ATTRIBUTE_MALLOC;
+extern char *make_temp_file (const char *) ATTRIBUTE_MALLOC;
 
 /* Remove a link to a file unless it is special. */
 
-extern int unlink_if_ordinary PARAMS((const char *));
+extern int unlink_if_ordinary (const char *);
 
 /* Allocate memory filled with spaces.  Allocates using malloc.  */
 
-extern const char *spaces PARAMS ((int count));
+extern const char *spaces (int count);
 
 /* Return the maximum error number for which strerror will return a
    string.  */
 
-extern int errno_max PARAMS ((void));
+extern int errno_max (void);
 
 /* Return the name of an errno value (e.g., strerrno (EINVAL) returns
    "EINVAL").  */
 
-extern const char *strerrno PARAMS ((int));
+extern const char *strerrno (int);
 
 /* Given the name of an errno value, return the value.  */
 
-extern int strtoerrno PARAMS ((const char *));
+extern int strtoerrno (const char *);
 
 /* ANSI's strerror(), but more robust.  */
 
-extern char *xstrerror PARAMS ((int));
+extern char *xstrerror (int);
 
 /* Return the maximum signal number for which strsignal will return a
    string.  */
 
-extern int signo_max PARAMS ((void));
+extern int signo_max (void);
 
 /* Return a signal message string for a signal number
    (e.g., strsignal (SIGHUP) returns something like "Hangup").  */
 /* This is commented out as it can conflict with one in system headers.
    We still document its existence though.  */
 
-/*extern const char *strsignal PARAMS ((int));*/
+/*extern const char *strsignal (int);*/
 
 /* Return the name of a signal number (e.g., strsigno (SIGHUP) returns
    "SIGHUP").  */
 
-extern const char *strsigno PARAMS ((int));
+extern const char *strsigno (int);
 
 /* Given the name of a signal, return its number.  */
 
-extern int strtosigno PARAMS ((const char *));
+extern int strtosigno (const char *);
 
 /* Register a function to be run by xexit.  Returns 0 on success.  */
 
-extern int xatexit PARAMS ((void (*fn) (void)));
+extern int xatexit (void (*fn) (void));
 
 /* Exit, calling all the functions registered with xatexit.  */
 
-extern void xexit PARAMS ((int status)) ATTRIBUTE_NORETURN;
+extern void xexit (int status) ATTRIBUTE_NORETURN;
 
 /* Set the program name used by xmalloc.  */
 
-extern void xmalloc_set_program_name PARAMS ((const char *));
+extern void xmalloc_set_program_name (const char *);
 
 /* Report an allocation failure.  */
-extern void xmalloc_failed PARAMS ((size_t)) ATTRIBUTE_NORETURN;
+extern void xmalloc_failed (size_t) ATTRIBUTE_NORETURN;
 
 /* Allocate memory without fail.  If malloc fails, this will print a
    message to stderr (using the name set by xmalloc_set_program_name,
    if any) and then call xexit.  */
 
-extern PTR xmalloc PARAMS ((size_t)) ATTRIBUTE_MALLOC;
+extern PTR xmalloc (size_t) ATTRIBUTE_MALLOC;
 
 /* Reallocate memory without fail.  This works like xmalloc.  Note,
    realloc type functions are not suitable for attribute malloc since
    they may return the same address across multiple calls. */
 
-extern PTR xrealloc PARAMS ((PTR, size_t));
+extern PTR xrealloc (PTR, size_t);
 
 /* Allocate memory without fail and set it to zero.  This works like
    xmalloc.  */
 
-extern PTR xcalloc PARAMS ((size_t, size_t)) ATTRIBUTE_MALLOC;
+extern PTR xcalloc (size_t, size_t) ATTRIBUTE_MALLOC;
 
 /* Copy a string into a memory buffer without fail.  */
 
-extern char *xstrdup PARAMS ((const char *)) ATTRIBUTE_MALLOC;
+extern char *xstrdup (const char *) ATTRIBUTE_MALLOC;
 
 /* Copy at most N characters from string into a buffer without fail.  */
 
-extern char *xstrndup PARAMS ((const char *, size_t)) ATTRIBUTE_MALLOC;
+extern char *xstrndup (const char *, size_t) ATTRIBUTE_MALLOC;
 
 /* Copy an existing memory buffer to a new memory buffer without fail.  */
 
-extern PTR xmemdup PARAMS ((const PTR, size_t, size_t)) ATTRIBUTE_MALLOC;
+extern PTR xmemdup (const PTR, size_t, size_t) ATTRIBUTE_MALLOC;
 
 /* Physical memory routines.  Return values are in BYTES.  */
-extern double physmem_total PARAMS ((void));
-extern double physmem_available PARAMS ((void));
+extern double physmem_total (void);
+extern double physmem_available (void);
 
 
 /* These macros provide a K&R/C89/C++-friendly way of allocating structures
@@ -303,7 +301,7 @@ extern double physmem_available PARAMS ((void));
 #define _hex_array_size 256
 #define _hex_bad	99
 extern const unsigned char _hex_value[_hex_array_size];
-extern void hex_init PARAMS ((void));
+extern void hex_init (void);
 #define hex_p(c)	(hex_value (c) != _hex_bad)
 /* If you change this, note well: Some code relies on side effects in
    the argument being performed exactly once.  */
@@ -319,25 +317,25 @@ extern void hex_init PARAMS ((void));
 
 /* Execute a program.  */
 
-extern int pexecute PARAMS ((const char *, char * const *, const char *,
-			    const char *, char **, char **, int));
+extern int pexecute (const char *, char * const *, const char *,
+                     const char *, char **, char **, int);
 
 /* Wait for pexecute to finish.  */
 
-extern int pwait PARAMS ((int, int *, int));
+extern int pwait (int, int *, int);
 
 #if !HAVE_DECL_ASPRINTF
 /* Like sprintf but provides a pointer to malloc'd storage, which must
    be freed by the caller.  */
 
-extern int asprintf PARAMS ((char **, const char *, ...)) ATTRIBUTE_PRINTF_2;
+extern int asprintf (char **, const char *, ...) ATTRIBUTE_PRINTF_2;
 #endif
 
 #if !HAVE_DECL_VASPRINTF
 /* Like vsprintf but provides a pointer to malloc'd storage, which
    must be freed by the caller.  */
 
-extern int vasprintf PARAMS ((char **, const char *, va_list))
+extern int vasprintf (char **, const char *, va_list)
   ATTRIBUTE_PRINTF(2,0);
 #endif
 
@@ -349,7 +347,7 @@ extern int vasprintf PARAMS ((char **, const char *, va_list))
    USE_C_ALLOCA yourself.  The canonical autoconf macro C_ALLOCA is
    also set/unset as it is often used to indicate whether code needs
    to call alloca(0).  */
-extern PTR C_alloca PARAMS ((size_t)) ATTRIBUTE_MALLOC;
+extern PTR C_alloca (size_t) ATTRIBUTE_MALLOC;
 #undef alloca
 #if GCC_VERSION >= 2000 && !defined USE_C_ALLOCA
 # define alloca(x) __builtin_alloca(x)