+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.
} 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 {
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 {
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
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
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.
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_*
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
}
#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
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
/* 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
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. */
/* 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
#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
#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. */
/* 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
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)
+2005-03-27 Gabriel Dos Reis <gdr@integrable-solutions.net>
+
+ Convert libiberty to use ISO C prototype style 3/n.
+ * cplus-dem.c (set_cplus_marker_for_demangling, consume_count,
+ consume_count_with_underscores, code_for_qualifier,
+ qualifier_string, demangle_qualifier, cplus_demangle_opname,
+ cplus_mangle_opname, cplus_demangle_set_style,
+ cplus_demangle_name_to_style, cplus_demangle, grow_vect,
+ ada_demangle, internal_cplus_demangle, squangle_mop_up,
+ work_stuff_copy_to_from, delete_non_B_K_work_stuff,
+ delete_work_stuff, mop_up, demangle_signature,
+ demangle_method_args, demangle_template_template_parm,
+ demangle_expression, demangle_integral_value,
+ demangle_real_value, demangle_template_value_parm,
+ demangle_template, arm_pt, demangle_arm_hp_template,
+ demangle_class_name, demangle_class, iterate_demangle_function,
+ demangle_prefix, gnu_special, recursively_demangle, arm_special,
+ demangle_qualified, get_count, do_type, demangle_fund_type,
+ do_hpacc_template_const_value, do_hpacc_template_literal,
+ snarf_numeric_literal, do_arg, remember_type, remember_Ktype,
+ register_Btype, remember_Btype, forget_B_and_K_types,
+ forget_types, demangle_args, demangle_nested_args,
+ demangle_function_name, string_need, string_delete, string_init,
+ string_clear, string_empty, string_append, string_appends,
+ string_appendn, string_prepend, string_prepends, string_prependn,
+ string_append_template_idx): Use ISO C prootype style.
+ * cp-demint.c (cplus_demangle_fill_component,
+ cplus_demangle_fill_builtin_type, cplus_demangle_fill_operator,
+ cplus_demangle_v3_components): Likewise.
+
+2005-03-26 Gabriel Dos Reis <gdr@integrable-solutions.net>
+
+ Convert libiberty to use ISO C prototype style 2/n.
+ * cp-demangle.h: Remove uses of PARAMS.
+ * cp-demangle.c: Likewise.
+ (d_dump, cplus_demangle_fill_name,
+ cplus_demangle_fill_extended_operator, cplus_demangle_fill_ctor,
+ cplus_demangle_fill_dtor, d_make_empty, d_make_comp, d_make_name,
+ d_make_builtin_type, d_make_operator, d_make_extended_operator,
+ d_make_ctor, d_make_dtor, d_make_template_param, d_make_sub,
+ cplus_demangle_mangled_name, has_return_type,
+ is_ctor_dtor_or_conversion, d_encoding, d_name, d_nested_name,
+ d_prefix, d_unqualified_name, d_source_name, d_number,
+ d_identifier, d_operator_name, d_special_name, d_call_offset,
+ d_ctor_dtor_name, cplus_demangle_type, d_cv_qualifiers,
+ d_function_type, d_bare_function_type, d_class_enum_type,
+ d_array_type, d_pointer_to_member_type, d_template_param,
+ d_template_args, d_template_arg, d_expression, d_expr_primary,
+ d_local_name, d_discriminator, d_add_substitution,
+ d_substitution, d_print_resize, d_print_append_char,
+ d_print_append_buffer, d_print_error, cplus_demangle_print,
+ d_print_comp, d_print_java_identifier, d_print_mod_list,
+ d_print_mod, d_print_function_type, d_print_array_type,
+ d_print_expr_op, d_print_cast, cplus_demangle_init_info,
+ d_demangle, __cxa_demangle, cplus_demangle_v3, java_demangle_v3,
+ is_ctor_or_dtor, is_gnu_v3_mangled_ctor, is_gnu_v3_mangled_dtor,
+ print_usage, main):
+
+2005-03-26 Gabriel Dos Reis <gdr@integrable-solutions.net>
+
+ Convert libiberty to ISO C prototype style 1/n.
+ * _doprnt.c: Remove conditional #include <varargs.h> on
+ ANSI_PROTOTYPES as the latter is always assumed.
+ (_doprnt, checkit, main): Use ISO C prototype.
+ * alloca.c (find_stack_direction, C_alloca): Use ISO C prototype.
+ * argv.c: Remove conditional #includes on ANSI_PROTOTYPES.
+ (dupargv, freeargv, buildargv, main): Use ISO C prototype.
+ * atexit.c (atexit): Likewise
+ * asprintf.c: Remove conditional include on ANSI_PROTOTYPES.
+ (asprintf): Use ISO C prototype.
+ * basename.c (basename): Likewise
+ * bcmp.c (bcmp): Likewise.
+ * bcopy.c (bcopy): Likewise.
+ * bzero.c (bzero): Likewise.
+ * bsearch.c (bsearch): Likewise. Improve const-correctness.
+ * choose-temp.c (choose_temp_base): Likewise.
+ * calloc.c: Remove conditional #include on ANSI_PROTOTYPES.
+ (calloc): Use ISO C prototype.
+ * clock.c (clock): Likewise.
+ * concat.c: Remove conditional #include on ANSI_PROTOTYPES.
+ (vconcat_length, vconcat_copy, concat_length, concat_copy,
+ concat_copy2, concat, reconcat, main): Use ISO C prototype.
+ * copysign.c (copysign): Likewise.
+
2005-03-24 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* Makefile.in (CFILES): Add strndup.c and xstrndup.c.
#include "safe-ctype.h"
#include <stdio.h>
-#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
} while (0)
int
-_doprnt (format, ap, stream)
- const char * format;
- va_list ap;
- FILE * stream;
+_doprnt (const char *format, va_list ap, FILE *stream)
{
const char * ptr = format;
char specifier[128];
fflush(stdin); \
} while (0)
-static int checkit PARAMS ((const char * format, ...)) ATTRIBUTE_PRINTF_1;
+static int checkit (const char * format, ...) ATTRIBUTE_PRINTF_1;
static int
-checkit VPARAMS ((const char* format, ...))
+checkit (const char* format, ...)
{
int result;
VA_OPEN (args, format);
}
int
-main ()
+main (void)
{
RESULT(checkit ("<%d>\n", 0x12345678));
RESULT(printf ("<%d>\n", 0x12345678));
#define STACK_DIR stack_dir
static void
-find_stack_direction ()
+find_stack_direction (void)
{
static char *addr = NULL; /* Address of first `dummy', once known. */
auto char dummy; /* To get stack address. */
/* @undocumented C_alloca */
PTR
-C_alloca (size)
- size_t size;
+C_alloca (size_t size)
{
auto char probe; /* Probes stack depth: */
register char *depth = ADDRESS_FUNCTION (probe);
/* Routines imported from standard C runtime libraries. */
-#ifdef ANSI_PROTOTYPES
-
#include <stddef.h>
#include <string.h>
#include <stdlib.h>
-#else /* !ANSI_PROTOTYPES */
-
-#if !defined _WIN32 || defined __GNUC__
-extern char *memcpy (); /* Copy memory region */
-extern int strlen (); /* Count length of string */
-extern char *malloc (); /* Standard memory allocater */
-extern char *realloc (); /* Standard memory reallocator */
-extern void free (); /* Free malloc'd memory */
-extern char *strdup (); /* Duplicate a string */
-#endif
-
-#endif /* ANSI_PROTOTYPES */
-
-
#ifndef NULL
#define NULL 0
#endif
*/
char **
-dupargv (argv)
- char **argv;
+dupargv (char **argv)
{
int argc;
char **copy;
*/
-void freeargv (vector)
-char **vector;
+void freeargv (char **vector)
{
register char **scan;
*/
-char **buildargv (input)
- const char *input;
+char **buildargv (const char *input)
{
char *arg;
char *copybuf;
NULL
};
-int main ()
+int
+main (void)
{
char **argv;
const char *const *test;
#include "ansidecl.h"
#include "libiberty.h"
-#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
/*
*/
int
-asprintf VPARAMS ((char **buf, const char *fmt, ...))
+asprintf (char **buf, const char *fmt, ...)
{
int status;
VA_OPEN (ap, fmt);
#ifdef HAVE_ON_EXIT
int
-atexit(f)
- void (*f)();
+atexit(void (*f)(void))
{
/* If the system doesn't provide a definition for atexit, use on_exit
if the system provides that. */
#endif /* DIR_SEPARATOR_2 */
char *
-basename (name)
- const char *name;
+basename (const char *name)
{
const char *base;
int
-bcmp (from, to, count)
- char *from, *to;
- int count;
+bcmp (char *from, char *to, int count)
{
int rtnval = 0;
*/
void
-bcopy (src, dest, len)
- register char *src, *dest;
- int len;
+bcopy (register char *src, register char *dest, int len)
{
if (dest < src)
while (len--)
* look at item 3.
*/
void *
-bsearch(key, base0, nmemb, size, compar)
- register void *key;
- void *base0;
- size_t nmemb;
- register size_t size;
- register int (*compar)();
+bsearch (register const void *key, const void *base0,
+ size_t nmemb, register size_t size,
+ register int (*compar)(const void *, const void *))
{
- register char *base = base0;
+ register const char *base = (const char *) base0;
register int lim, cmp;
- register void *p;
+ register const void *p;
for (lim = nmemb; lim != 0; lim >>= 1) {
p = base + (lim >> 1) * size;
if (cmp == 0)
return (p);
if (cmp > 0) { /* key > p: move right */
- base = (char *)p + size;
+ base = (const char *)p + size;
lim--;
} /* else move left */
}
void
-bzero (to, count)
- char *to;
- int count;
+bzero (char *to, int count)
{
while (count-- > 0)
{
*/
#include "ansidecl.h"
-#ifdef ANSI_PROTOTYPES
#include <stddef.h>
-#else
-#define size_t unsigned long
-#endif
/* For systems with larger pointers than ints, this must be declared. */
-PTR malloc PARAMS ((size_t));
-void bzero PARAMS ((PTR, size_t));
+PTR malloc (size_t);
+void bzero (PTR, size_t);
PTR
-calloc (nelem, elsize)
- size_t nelem, elsize;
+calloc (size_t nelem, size_t elsize)
{
register PTR ptr;
#endif
#include "libiberty.h"
-extern char *choose_tmpdir PARAMS ((void));
+extern char *choose_tmpdir (void);
/* Name of temporary file.
mktemp requires 6 trailing X's. */
*/
char *
-choose_temp_base ()
+choose_temp_base (void)
{
const char *base = choose_tmpdir ();
char *temp_filename;
/* FIXME: should be able to declare as clock_t. */
long
-clock ()
+clock (void)
{
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
#include "libiberty.h"
#include <sys/types.h> /* size_t */
-#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
# if HAVE_STRING_H
# include <string.h>
#include <stdlib.h>
#endif
-static inline unsigned long vconcat_length PARAMS ((const char *, va_list));
+static inline unsigned long vconcat_length (const char *, va_list);
static inline unsigned long
-vconcat_length (first, args)
- const char *first;
- va_list args;
+vconcat_length (const char *first, va_list args)
{
unsigned long length = 0;
const char *arg;
return length;
}
-static inline char *vconcat_copy PARAMS ((char *, const char *, va_list));
static inline char *
-vconcat_copy (dst, first, args)
- char *dst;
- const char *first;
- va_list args;
+vconcat_copy (char *dst, const char *first, va_list args)
{
char *end = dst;
const char *arg;
/* @undocumented concat_length */
unsigned long
-concat_length VPARAMS ((const char *first, ...))
+concat_length (const char *first, ...)
{
unsigned long length;
/* @undocumented concat_copy */
char *
-concat_copy VPARAMS ((char *dst, const char *first, ...))
+concat_copy (char *dst, const char *first, ...)
{
char *save_dst;
/* @undocumented concat_copy2 */
char *
-concat_copy2 VPARAMS ((const char *first, ...))
+concat_copy2 (const char *first, ...)
{
VA_OPEN (args, first);
VA_FIXEDARG (args, const char *, first);
}
char *
-concat VPARAMS ((const char *first, ...))
+concat (const char *first, ...)
{
char *newstr;
*/
char *
-reconcat VPARAMS ((char *optr, const char *first, ...))
+reconcat (char *optr, const char *first, ...)
{
char *newstr;
#include <stdio.h>
int
-main ()
+main (void)
{
printf ("\"\" = \"%s\"\n", concat (NULLP));
printf ("\"a\" = \"%s\"\n", concat ("a", NULLP));
#if defined(__IEEE_BIG_ENDIAN) || defined(__IEEE_LITTLE_ENDIAN)
double
-copysign (x, y)
- double x, y;
+copysign (double x, double y)
{
__ieee_double_shape_type a,b;
b.value = y;
#else
double
-copysign (x, y)
- double x, y;
+copysign (double x, double y)
{
if ((x < 0 && y > 0) || (x > 0 && y < 0))
return -x;
#define CP_STATIC_IF_GLIBCPP_V3 static
#define cplus_demangle_fill_name d_fill_name
-static int
-d_fill_name PARAMS ((struct demangle_component *, const char *, int));
+static int d_fill_name (struct demangle_component *, const char *, int);
#define cplus_demangle_fill_extended_operator d_fill_extended_operator
static int
-d_fill_extended_operator PARAMS ((struct demangle_component *, int,
- struct demangle_component *));
+d_fill_extended_operator (struct demangle_component *, int,
+ struct demangle_component *);
#define cplus_demangle_fill_ctor d_fill_ctor
static int
-d_fill_ctor PARAMS ((struct demangle_component *, enum gnu_v3_ctor_kinds,
- struct demangle_component *));
+d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
+ struct demangle_component *);
#define cplus_demangle_fill_dtor d_fill_dtor
static int
-d_fill_dtor PARAMS ((struct demangle_component *, enum gnu_v3_dtor_kinds,
- struct demangle_component *));
+d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
+ struct demangle_component *);
#define cplus_demangle_mangled_name d_mangled_name
-static struct demangle_component *
-d_mangled_name PARAMS ((struct d_info *, int));
+static struct demangle_component *d_mangled_name (struct d_info *, int);
#define cplus_demangle_type d_type
-static struct demangle_component *
-d_type PARAMS ((struct d_info *));
+static struct demangle_component *d_type (struct d_info *);
#define cplus_demangle_print d_print
-static char *
-d_print PARAMS ((int, const struct demangle_component *, int, size_t *));
+static char *d_print (int, const struct demangle_component *, int, size_t *);
#define cplus_demangle_init_info d_init_info
-static void
-d_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+static void d_init_info (const char *, int, size_t, struct d_info *);
#else /* ! defined(IN_GLIBCPP_V3) */
#define CP_STATIC_IF_GLIBCPP_V3
((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
#ifdef CP_DEMANGLE_DEBUG
-static void
-d_dump PARAMS ((struct demangle_component *, int));
+static void d_dump (struct demangle_component *, int);
#endif
static struct demangle_component *
-d_make_empty PARAMS ((struct d_info *));
+d_make_empty (struct d_info *);
static struct demangle_component *
-d_make_comp PARAMS ((struct d_info *, enum demangle_component_type,
- struct demangle_component *,
- struct demangle_component *));
+d_make_comp (struct d_info *, enum demangle_component_type,
+ struct demangle_component *,
+ struct demangle_component *);
static struct demangle_component *
-d_make_name PARAMS ((struct d_info *, const char *, int));
+d_make_name (struct d_info *, const char *, int);
static struct demangle_component *
-d_make_builtin_type PARAMS ((struct d_info *,
- const struct demangle_builtin_type_info *));
+d_make_builtin_type (struct d_info *,
+ const struct demangle_builtin_type_info *);
static struct demangle_component *
-d_make_operator PARAMS ((struct d_info *,
- const struct demangle_operator_info *));
+d_make_operator (struct d_info *,
+ const struct demangle_operator_info *);
static struct demangle_component *
-d_make_extended_operator PARAMS ((struct d_info *, int,
- struct demangle_component *));
+d_make_extended_operator (struct d_info *, int,
+ struct demangle_component *);
static struct demangle_component *
-d_make_ctor PARAMS ((struct d_info *, enum gnu_v3_ctor_kinds,
- struct demangle_component *));
+d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
+ struct demangle_component *);
static struct demangle_component *
-d_make_dtor PARAMS ((struct d_info *, enum gnu_v3_dtor_kinds,
- struct demangle_component *));
+d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
+ struct demangle_component *);
static struct demangle_component *
-d_make_template_param PARAMS ((struct d_info *, long));
+d_make_template_param (struct d_info *, long);
static struct demangle_component *
-d_make_sub PARAMS ((struct d_info *, const char *, int));
+d_make_sub (struct d_info *, const char *, int);
static int
-has_return_type PARAMS ((struct demangle_component *));
+has_return_type (struct demangle_component *);
static int
-is_ctor_dtor_or_conversion PARAMS ((struct demangle_component *));
+is_ctor_dtor_or_conversion (struct demangle_component *);
-static struct demangle_component *
-d_encoding PARAMS ((struct d_info *, int));
+static struct demangle_component *d_encoding (struct d_info *, int);
-static struct demangle_component *
-d_name PARAMS ((struct d_info *));
+static struct demangle_component *d_name (struct d_info *);
-static struct demangle_component *
-d_nested_name PARAMS ((struct d_info *));
+static struct demangle_component *d_nested_name (struct d_info *);
-static struct demangle_component *
-d_prefix PARAMS ((struct d_info *));
+static struct demangle_component *d_prefix (struct d_info *);
-static struct demangle_component *
-d_unqualified_name PARAMS ((struct d_info *));
+static struct demangle_component *d_unqualified_name (struct d_info *);
-static struct demangle_component *
-d_source_name PARAMS ((struct d_info *));
+static struct demangle_component *d_source_name (struct d_info *);
-static long
-d_number PARAMS ((struct d_info *));
+static long d_number (struct d_info *);
-static struct demangle_component *
-d_identifier PARAMS ((struct d_info *, int));
+static struct demangle_component *d_identifier (struct d_info *, int);
-static struct demangle_component *
-d_operator_name PARAMS ((struct d_info *));
+static struct demangle_component *d_operator_name (struct d_info *);
-static struct demangle_component *
-d_special_name PARAMS ((struct d_info *));
+static struct demangle_component *d_special_name (struct d_info *);
-static int
-d_call_offset PARAMS ((struct d_info *, int));
+static int d_call_offset (struct d_info *, int);
-static struct demangle_component *
-d_ctor_dtor_name PARAMS ((struct d_info *));
+static struct demangle_component *d_ctor_dtor_name (struct d_info *);
static struct demangle_component **
-d_cv_qualifiers PARAMS ((struct d_info *, struct demangle_component **, int));
+d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
static struct demangle_component *
-d_function_type PARAMS ((struct d_info *));
+d_function_type (struct d_info *);
static struct demangle_component *
-d_bare_function_type PARAMS ((struct d_info *, int));
+d_bare_function_type (struct d_info *, int);
static struct demangle_component *
-d_class_enum_type PARAMS ((struct d_info *));
+d_class_enum_type (struct d_info *);
-static struct demangle_component *
-d_array_type PARAMS ((struct d_info *));
+static struct demangle_component *d_array_type (struct d_info *);
static struct demangle_component *
-d_pointer_to_member_type PARAMS ((struct d_info *));
+d_pointer_to_member_type (struct d_info *);
static struct demangle_component *
-d_template_param PARAMS ((struct d_info *));
+d_template_param (struct d_info *);
-static struct demangle_component *
-d_template_args PARAMS ((struct d_info *));
+static struct demangle_component *d_template_args (struct d_info *);
static struct demangle_component *
-d_template_arg PARAMS ((struct d_info *));
+d_template_arg (struct d_info *);
-static struct demangle_component *
-d_expression PARAMS ((struct d_info *));
+static struct demangle_component *d_expression (struct d_info *);
-static struct demangle_component *
-d_expr_primary PARAMS ((struct d_info *));
+static struct demangle_component *d_expr_primary (struct d_info *);
-static struct demangle_component *
-d_local_name PARAMS ((struct d_info *));
+static struct demangle_component *d_local_name (struct d_info *);
-static int
-d_discriminator PARAMS ((struct d_info *));
+static int d_discriminator (struct d_info *);
static int
-d_add_substitution PARAMS ((struct d_info *, struct demangle_component *));
+d_add_substitution (struct d_info *, struct demangle_component *);
-static struct demangle_component *
-d_substitution PARAMS ((struct d_info *, int));
+static struct demangle_component *d_substitution (struct d_info *, int);
-static void
-d_print_resize PARAMS ((struct d_print_info *, size_t));
+static void d_print_resize (struct d_print_info *, size_t);
-static void
-d_print_append_char PARAMS ((struct d_print_info *, int));
+static void d_print_append_char (struct d_print_info *, int);
static void
-d_print_append_buffer PARAMS ((struct d_print_info *, const char *, size_t));
+d_print_append_buffer (struct d_print_info *, const char *, size_t);
-static void
-d_print_error PARAMS ((struct d_print_info *));
+static void d_print_error (struct d_print_info *);
static void
-d_print_comp PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_comp (struct d_print_info *, const struct demangle_component *);
static void
-d_print_java_identifier PARAMS ((struct d_print_info *, const char *, int));
+d_print_java_identifier (struct d_print_info *, const char *, int);
static void
-d_print_mod_list PARAMS ((struct d_print_info *, struct d_print_mod *, int));
+d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
static void
-d_print_mod PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_mod (struct d_print_info *, const struct demangle_component *);
static void
-d_print_function_type PARAMS ((struct d_print_info *,
- const struct demangle_component *,
- struct d_print_mod *));
+d_print_function_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
static void
-d_print_array_type PARAMS ((struct d_print_info *,
- const struct demangle_component *,
- struct d_print_mod *));
+d_print_array_type (struct d_print_info *,
+ const struct demangle_component *,
+ struct d_print_mod *);
static void
-d_print_expr_op PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_expr_op (struct d_print_info *, const struct demangle_component *);
static void
-d_print_cast PARAMS ((struct d_print_info *,
- const struct demangle_component *));
+d_print_cast (struct d_print_info *, const struct demangle_component *);
-static char *
-d_demangle PARAMS ((const char *, int, size_t *));
+static char *d_demangle (const char *, int, size_t *);
#ifdef CP_DEMANGLE_DEBUG
static void
-d_dump (dc, indent)
- struct demangle_component *dc;
- int indent;
+d_dump (struct demangle_component *dc, int indent)
{
int i;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_name (p, s, len)
- struct demangle_component *p;
- const char *s;
- int len;
+cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
{
if (p == NULL || s == NULL || len == 0)
return 0;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_extended_operator (p, args, name)
- struct demangle_component *p;
- int args;
- struct demangle_component *name;
+cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
+ struct demangle_component *name)
{
if (p == NULL || args < 0 || name == NULL)
return 0;
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_ctor (p, kind, name)
- struct demangle_component *p;
- enum gnu_v3_ctor_kinds kind;
- struct demangle_component *name;
+cplus_demangle_fill_ctor (struct demangle_component *p,
+ enum gnu_v3_ctor_kinds kind,
+ struct demangle_component *name)
{
if (p == NULL
|| name == NULL
CP_STATIC_IF_GLIBCPP_V3
int
-cplus_demangle_fill_dtor (p, kind, name)
- struct demangle_component *p;
- enum gnu_v3_dtor_kinds kind;
- struct demangle_component *name;
+cplus_demangle_fill_dtor (struct demangle_component *p,
+ enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name)
{
if (p == NULL
|| name == NULL
/* Add a new component. */
static struct demangle_component *
-d_make_empty (di)
- struct d_info *di;
+d_make_empty (struct d_info *di)
{
struct demangle_component *p;
/* Add a new generic component. */
static struct demangle_component *
-d_make_comp (di, type, left, right)
- struct d_info *di;
- enum demangle_component_type type;
- struct demangle_component *left;
- struct demangle_component *right;
+d_make_comp (struct d_info *di, enum demangle_component_type type,
+ struct demangle_component *left,
+ struct demangle_component *right)
{
struct demangle_component *p;
/* Add a new name component. */
static struct demangle_component *
-d_make_name (di, s, len)
- struct d_info *di;
- const char *s;
- int len;
+d_make_name (struct d_info *di, const char *s, int len)
{
struct demangle_component *p;
/* Add a new builtin type component. */
static struct demangle_component *
-d_make_builtin_type (di, type)
- struct d_info *di;
- const struct demangle_builtin_type_info *type;
+d_make_builtin_type (struct d_info *di,
+ const struct demangle_builtin_type_info *type)
{
struct demangle_component *p;
/* Add a new operator component. */
static struct demangle_component *
-d_make_operator (di, op)
- struct d_info *di;
- const struct demangle_operator_info *op;
+d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
{
struct demangle_component *p;
/* Add a new extended operator component. */
static struct demangle_component *
-d_make_extended_operator (di, args, name)
- struct d_info *di;
- int args;
- struct demangle_component *name;
+d_make_extended_operator (struct d_info *di, int args,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new constructor component. */
static struct demangle_component *
-d_make_ctor (di, kind, name)
- struct d_info *di;
- enum gnu_v3_ctor_kinds kind;
- struct demangle_component *name;
+d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new destructor component. */
static struct demangle_component *
-d_make_dtor (di, kind, name)
- struct d_info *di;
- enum gnu_v3_dtor_kinds kind;
- struct demangle_component *name;
+d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name)
{
struct demangle_component *p;
/* Add a new template parameter. */
static struct demangle_component *
-d_make_template_param (di, i)
- struct d_info *di;
- long i;
+d_make_template_param (struct d_info *di, long i)
{
struct demangle_component *p;
/* Add a new standard substitution component. */
static struct demangle_component *
-d_make_sub (di, name, len)
- struct d_info *di;
- const char *name;
- int len;
+d_make_sub (struct d_info *di, const char *name, int len)
{
struct demangle_component *p;
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_mangled_name (di, top_level)
- struct d_info *di;
- int top_level;
+cplus_demangle_mangled_name (struct d_info *di, int top_level)
{
if (d_next_char (di) != '_')
return NULL;
return types. */
static int
-has_return_type (dc)
- struct demangle_component *dc;
+has_return_type (struct demangle_component *dc)
{
if (dc == NULL)
return 0;
conversion operator. */
static int
-is_ctor_dtor_or_conversion (dc)
- struct demangle_component *dc;
+is_ctor_dtor_or_conversion (struct demangle_component *dc)
{
if (dc == NULL)
return 0;
we would not correctly demangle names in local scopes. */
static struct demangle_component *
-d_encoding (di, top_level)
- struct d_info *di;
- int top_level;
+d_encoding (struct d_info *di, int top_level)
{
char peek = d_peek_char (di);
*/
static struct demangle_component *
-d_name (di)
- struct d_info *di;
+d_name (struct d_info *di)
{
char peek = d_peek_char (di);
struct demangle_component *dc;
*/
static struct demangle_component *
-d_nested_name (di)
- struct d_info *di;
+d_nested_name (struct d_info *di)
{
struct demangle_component *ret;
struct demangle_component **pret;
*/
static struct demangle_component *
-d_prefix (di)
- struct d_info *di;
+d_prefix (struct d_info *di)
{
struct demangle_component *ret = NULL;
*/
static struct demangle_component *
-d_unqualified_name (di)
- struct d_info *di;
+d_unqualified_name (struct d_info *di)
{
char peek;
/* <source-name> ::= <(positive length) number> <identifier> */
static struct demangle_component *
-d_source_name (di)
- struct d_info *di;
+d_source_name (struct d_info *di)
{
long len;
struct demangle_component *ret;
/* number ::= [n] <(non-negative decimal integer)> */
static long
-d_number (di)
- struct d_info *di;
+d_number (struct d_info *di)
{
int negative;
char peek;
/* identifier ::= <(unqualified source code identifier)> */
static struct demangle_component *
-d_identifier (di, len)
- struct d_info *di;
- int len;
+d_identifier (struct d_info *di, int len)
{
const char *name;
};
static struct demangle_component *
-d_operator_name (di)
- struct d_info *di;
+d_operator_name (struct d_info *di)
{
char c1;
char c2;
*/
static struct demangle_component *
-d_special_name (di)
- struct d_info *di;
+d_special_name (struct d_info *di)
{
char c;
display it in verbose mode. */
static int
-d_call_offset (di, c)
- struct d_info *di;
- int c;
+d_call_offset (struct d_info *di, int c)
{
if (c == '\0')
c = d_next_char (di);
*/
static struct demangle_component *
-d_ctor_dtor_name (di)
- struct d_info *di;
+d_ctor_dtor_name (struct d_info *di)
{
if (di->last_name != NULL)
{
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_type (di)
- struct d_info *di;
+cplus_demangle_type (struct d_info *di)
{
char peek;
struct demangle_component *ret;
/* <CV-qualifiers> ::= [r] [V] [K] */
static struct demangle_component **
-d_cv_qualifiers (di, pret, member_fn)
- struct d_info *di;
- struct demangle_component **pret;
- int member_fn;
+d_cv_qualifiers (struct d_info *di,
+ struct demangle_component **pret, int member_fn)
{
char peek;
/* <function-type> ::= F [Y] <bare-function-type> E */
static struct demangle_component *
-d_function_type (di)
- struct d_info *di;
+d_function_type (struct d_info *di)
{
struct demangle_component *ret;
/* <bare-function-type> ::= <type>+ */
static struct demangle_component *
-d_bare_function_type (di, has_return_type)
- struct d_info *di;
- int has_return_type;
+d_bare_function_type (struct d_info *di, int has_return_type)
{
struct demangle_component *return_type;
struct demangle_component *tl;
/* <class-enum-type> ::= <name> */
static struct demangle_component *
-d_class_enum_type (di)
- struct d_info *di;
+d_class_enum_type (struct d_info *di)
{
return d_name (di);
}
*/
static struct demangle_component *
-d_array_type (di)
- struct d_info *di;
+d_array_type (struct d_info *di)
{
char peek;
struct demangle_component *dim;
/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
static struct demangle_component *
-d_pointer_to_member_type (di)
- struct d_info *di;
+d_pointer_to_member_type (struct d_info *di)
{
struct demangle_component *cl;
struct demangle_component *mem;
*/
static struct demangle_component *
-d_template_param (di)
- struct d_info *di;
+d_template_param (struct d_info *di)
{
long param;
/* <template-args> ::= I <template-arg>+ E */
static struct demangle_component *
-d_template_args (di)
- struct d_info *di;
+d_template_args (struct d_info *di)
{
struct demangle_component *hold_last_name;
struct demangle_component *al;
*/
static struct demangle_component *
-d_template_arg (di)
- struct d_info *di;
+d_template_arg (struct d_info *di)
{
struct demangle_component *ret;
*/
static struct demangle_component *
-d_expression (di)
- struct d_info *di;
+d_expression (struct d_info *di)
{
char peek;
*/
static struct demangle_component *
-d_expr_primary (di)
- struct d_info *di;
+d_expr_primary (struct d_info *di)
{
struct demangle_component *ret;
*/
static struct demangle_component *
-d_local_name (di)
- struct d_info *di;
+d_local_name (struct d_info *di)
{
struct demangle_component *function;
We should print it out in verbose mode. */
static int
-d_discriminator (di)
- struct d_info *di;
+d_discriminator (struct d_info *di)
{
long discrim;
/* Add a new substitution. */
static int
-d_add_substitution (di, dc)
- struct d_info *di;
- struct demangle_component *dc;
+d_add_substitution (struct d_info *di, struct demangle_component *dc)
{
if (dc == NULL)
return 0;
};
static struct demangle_component *
-d_substitution (di, prefix)
- struct d_info *di;
- int prefix;
+d_substitution (struct d_info *di, int prefix)
{
char c;
/* Resize the print buffer. */
static void
-d_print_resize (dpi, add)
- struct d_print_info *dpi;
- size_t add;
+d_print_resize (struct d_print_info *dpi, size_t add)
{
size_t need;
/* Append a character to the print buffer. */
static void
-d_print_append_char (dpi, c)
- struct d_print_info *dpi;
- int c;
+d_print_append_char (struct d_print_info *dpi, int c)
{
if (dpi->buf != NULL)
{
/* Append a buffer to the print buffer. */
static void
-d_print_append_buffer (dpi, s, l)
- struct d_print_info *dpi;
- const char *s;
- size_t l;
+d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
{
if (dpi->buf != NULL)
{
/* Indicate that an error occurred during printing. */
static void
-d_print_error (dpi)
- struct d_print_info *dpi;
+d_print_error (struct d_print_info *dpi)
{
free (dpi->buf);
dpi->buf = NULL;
CP_STATIC_IF_GLIBCPP_V3
char *
-cplus_demangle_print (options, dc, estimate, palc)
- int options;
- const struct demangle_component *dc;
- int estimate;
- size_t *palc;
+cplus_demangle_print (int options, const struct demangle_component *dc,
+ int estimate, size_t *palc)
{
struct d_print_info dpi;
/* Subroutine to handle components. */
static void
-d_print_comp (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_comp (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (dc == NULL)
{
__U<hex-char>+_. */
static void
-d_print_java_identifier (dpi, name, len)
- struct d_print_info *dpi;
- const char *name;
- int len;
+d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
{
const char *p;
const char *end;
qualifiers on this after printing a function. */
static void
-d_print_mod_list (dpi, mods, suffix)
- struct d_print_info *dpi;
- struct d_print_mod *mods;
- int suffix;
+d_print_mod_list (struct d_print_info *dpi,
+ struct d_print_mod *mods, int suffix)
{
struct d_print_template *hold_dpt;
/* Print a modifier. */
static void
-d_print_mod (dpi, mod)
- struct d_print_info *dpi;
- const struct demangle_component *mod;
+d_print_mod (struct d_print_info *dpi,
+ const struct demangle_component *mod)
{
switch (mod->type)
{
/* Print a function type, except for the return type. */
static void
-d_print_function_type (dpi, dc, mods)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
- struct d_print_mod *mods;
+d_print_function_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
{
int need_paren;
int saw_mod;
/* Print an array type, except for the element type. */
static void
-d_print_array_type (dpi, dc, mods)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
- struct d_print_mod *mods;
+d_print_array_type (struct d_print_info *dpi,
+ const struct demangle_component *dc,
+ struct d_print_mod *mods)
{
int need_space;
/* Print an operator in an expression. */
static void
-d_print_expr_op (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_expr_op (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
d_append_buffer (dpi, dc->u.s_operator.op->name,
/* Print a cast. */
static void
-d_print_cast (dpi, dc)
- struct d_print_info *dpi;
- const struct demangle_component *dc;
+d_print_cast (struct d_print_info *dpi,
+ const struct demangle_component *dc)
{
if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
d_print_comp (dpi, d_left (dc));
CP_STATIC_IF_GLIBCPP_V3
void
-cplus_demangle_init_info (mangled, options, len, di)
- const char *mangled;
- int options;
- size_t len;
- struct d_info *di;
+cplus_demangle_init_info (const char *mangled, int options, size_t len,
+ struct d_info *di)
{
di->s = mangled;
di->send = mangled + len;
a memory allocation failure. On failure, this returns NULL. */
static char *
-d_demangle (mangled, options, palc)
- const char* mangled;
- int options;
- size_t *palc;
+d_demangle (const char* mangled, int options, size_t *palc)
{
size_t len;
int type;
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
-extern char *__cxa_demangle PARAMS ((const char *, char *, size_t *, int *));
+extern char *__cxa_demangle (const char *, char *, size_t *, int *);
/* ia64 ABI-mandated entry point in the C++ runtime library for
performing demangling. MANGLED_NAME is a NUL-terminated character
GNU extensions. */
char *
-__cxa_demangle (mangled_name, output_buffer, length, status)
- const char *mangled_name;
- char *output_buffer;
- size_t *length;
- int *status;
+__cxa_demangle (const char *mangled_name, char *output_buffer,
+ size_t *length, int *status)
{
char *demangled;
size_t alc;
demangled name. Otherwise, return NULL. */
char *
-cplus_demangle_v3 (mangled, options)
- const char* mangled;
- int options;
+cplus_demangle_v3 (const char* mangled, int options)
{
size_t alc;
of JArray<TYPE> with TYPE[]. */
char *
-java_demangle_v3 (mangled)
- const char* mangled;
+java_demangle_v3 (const char* mangled)
{
size_t alc;
char *demangled;
*DTOR_KIND appropriately. */
static int
-is_ctor_or_dtor (mangled, ctor_kind, dtor_kind)
- const char *mangled;
- enum gnu_v3_ctor_kinds *ctor_kind;
- enum gnu_v3_dtor_kinds *dtor_kind;
+is_ctor_or_dtor (const char *mangled,
+ enum gnu_v3_ctor_kinds *ctor_kind,
+ enum gnu_v3_dtor_kinds *dtor_kind)
{
struct d_info di;
struct demangle_component *dc;
name. A non-zero return indicates the type of constructor. */
enum gnu_v3_ctor_kinds
-is_gnu_v3_mangled_ctor (name)
- const char *name;
+is_gnu_v3_mangled_ctor (const char *name)
{
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
name. A non-zero return indicates the type of destructor. */
enum gnu_v3_dtor_kinds
-is_gnu_v3_mangled_dtor (name)
- const char *name;
+is_gnu_v3_mangled_dtor (const char *name)
{
enum gnu_v3_ctor_kinds ctor_kind;
enum gnu_v3_dtor_kinds dtor_kind;
/* Prints usage summary to FP and then exits with EXIT_VALUE. */
static void
-print_usage (fp, exit_value)
- FILE* fp;
- int exit_value;
+print_usage (FILE* fp, int exit_value)
{
fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
fprintf (fp, "Options:\n");
with their demangled equivalents. */
int
-main (argc, argv)
- int argc;
- char *argv[];
+main (int argc, char *argv[])
{
int i;
int opt_char;
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_mangled_name PARAMS ((struct d_info *, int));
+cplus_demangle_mangled_name (struct d_info *, int);
CP_STATIC_IF_GLIBCPP_V3
struct demangle_component *
-cplus_demangle_type PARAMS ((struct d_info *));
+cplus_demangle_type (struct d_info *);
extern void
-cplus_demangle_init_info PARAMS ((const char *, int, size_t, struct d_info *));
+cplus_demangle_init_info (const char *, int, size_t, struct d_info *);
/* cp-demangle.c needs to define this a little differently */
#undef CP_STATIC_IF_GLIBCPP_V3
/* Fill in most component types. */
int
-cplus_demangle_fill_component (p, type, left, right)
- struct demangle_component *p;
- enum demangle_component_type type;
- struct demangle_component *left;
- struct demangle_component *right;
+cplus_demangle_fill_component (struct demangle_component *p,
+ enum demangle_component_type type,
+ struct demangle_component *left,
+ struct demangle_component *right)
{
if (p == NULL)
return 0;
/* Fill in a DEMANGLE_COMPONENT_BUILTIN_TYPE. */
int
-cplus_demangle_fill_builtin_type (p, typename)
- struct demangle_component *p;
- const char *typename;
+cplus_demangle_fill_builtin_type (struct demangle_component *p,
+ const char *typename)
{
int len;
unsigned int i;
/* Fill in a DEMANGLE_COMPONENT_OPERATOR. */
int
-cplus_demangle_fill_operator (p, opname, args)
- struct demangle_component *p;
- const char *opname;
- int args;
+cplus_demangle_fill_operator (struct demangle_component *p,
+ const char *opname, int args)
{
int len;
unsigned int i;
/* Translate a mangled name into components. */
struct demangle_component *
-cplus_demangle_v3_components (mangled, options, mem)
- const char *mangled;
- int options;
- void **mem;
+cplus_demangle_v3_components (const char *mangled, int options, void **mem)
{
size_t len;
int type;
#include "libiberty.h"
-static char *ada_demangle PARAMS ((const char *, int));
+static char *ada_demangle (const char *, int);
#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
that will be output when using the `%d' format with `printf'. */
#define INTBUF_SIZE 32
-extern void fancy_abort PARAMS ((void)) ATTRIBUTE_NORETURN;
+extern void fancy_abort (void) ATTRIBUTE_NORETURN;
/* In order to allow a single demangler executable to demangle strings
using various common values of CPLUS_MARKER, as well as any specific
static char char_str[2] = { '\000', '\000' };
void
-set_cplus_marker_for_demangling (ch)
- int ch;
+set_cplus_marker_for_demangling (int ch)
{
cplus_markers[0] = ch;
}
/* Prototypes for local functions */
-static void
-delete_work_stuff PARAMS ((struct work_stuff *));
+static void delete_work_stuff (struct work_stuff *);
-static void
-delete_non_B_K_work_stuff PARAMS ((struct work_stuff *));
+static void delete_non_B_K_work_stuff (struct work_stuff *);
-static char *
-mop_up PARAMS ((struct work_stuff *, string *, int));
+static char *mop_up (struct work_stuff *, string *, int);
-static void
-squangle_mop_up PARAMS ((struct work_stuff *));
+static void squangle_mop_up (struct work_stuff *);
-static void
-work_stuff_copy_to_from PARAMS ((struct work_stuff *, struct work_stuff *));
+static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
#if 0
static int
-demangle_method_args PARAMS ((struct work_stuff *, const char **, string *));
+demangle_method_args (struct work_stuff *, const char **, string *);
#endif
static char *
-internal_cplus_demangle PARAMS ((struct work_stuff *, const char *));
+internal_cplus_demangle (struct work_stuff *, const char *);
static int
-demangle_template_template_parm PARAMS ((struct work_stuff *work,
- const char **, string *));
+demangle_template_template_parm (struct work_stuff *work,
+ const char **, string *);
static int
-demangle_template PARAMS ((struct work_stuff *work, const char **, string *,
- string *, int, int));
+demangle_template (struct work_stuff *work, const char **, string *,
+ string *, int, int);
static int
-arm_pt PARAMS ((struct work_stuff *, const char *, int, const char **,
- const char **));
+arm_pt (struct work_stuff *, const char *, int, const char **,
+ const char **);
static int
-demangle_class_name PARAMS ((struct work_stuff *, const char **, string *));
+demangle_class_name (struct work_stuff *, const char **, string *);
static int
-demangle_qualified PARAMS ((struct work_stuff *, const char **, string *,
- int, int));
+demangle_qualified (struct work_stuff *, const char **, string *,
+ int, int);
-static int
-demangle_class PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_class (struct work_stuff *, const char **, string *);
-static int
-demangle_fund_type PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_fund_type (struct work_stuff *, const char **, string *);
-static int
-demangle_signature PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_signature (struct work_stuff *, const char **, string *);
-static int
-demangle_prefix PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_prefix (struct work_stuff *, const char **, string *);
-static int
-gnu_special PARAMS ((struct work_stuff *, const char **, string *));
+static int gnu_special (struct work_stuff *, const char **, string *);
-static int
-arm_special PARAMS ((const char **, string *));
+static int arm_special (const char **, string *);
-static void
-string_need PARAMS ((string *, int));
+static void string_need (string *, int);
-static void
-string_delete PARAMS ((string *));
+static void string_delete (string *);
static void
-string_init PARAMS ((string *));
+string_init (string *);
-static void
-string_clear PARAMS ((string *));
+static void string_clear (string *);
#if 0
-static int
-string_empty PARAMS ((string *));
+static int string_empty (string *);
#endif
-static void
-string_append PARAMS ((string *, const char *));
+static void string_append (string *, const char *);
-static void
-string_appends PARAMS ((string *, string *));
+static void string_appends (string *, string *);
-static void
-string_appendn PARAMS ((string *, const char *, int));
+static void string_appendn (string *, const char *, int);
-static void
-string_prepend PARAMS ((string *, const char *));
+static void string_prepend (string *, const char *);
-static void
-string_prependn PARAMS ((string *, const char *, int));
+static void string_prependn (string *, const char *, int);
-static void
-string_append_template_idx PARAMS ((string *, int));
+static void string_append_template_idx (string *, int);
-static int
-get_count PARAMS ((const char **, int *));
+static int get_count (const char **, int *);
-static int
-consume_count PARAMS ((const char **));
+static int consume_count (const char **);
-static int
-consume_count_with_underscores PARAMS ((const char**));
+static int consume_count_with_underscores (const char**);
-static int
-demangle_args PARAMS ((struct work_stuff *, const char **, string *));
+static int demangle_args (struct work_stuff *, const char **, string *);
-static int
-demangle_nested_args PARAMS ((struct work_stuff*, const char**, string*));
+static int demangle_nested_args (struct work_stuff*, const char**, string*);
-static int
-do_type PARAMS ((struct work_stuff *, const char **, string *));
+static int do_type (struct work_stuff *, const char **, string *);
-static int
-do_arg PARAMS ((struct work_stuff *, const char **, string *));
+static int do_arg (struct work_stuff *, const char **, string *);
static void
-demangle_function_name PARAMS ((struct work_stuff *, const char **, string *,
- const char *));
+demangle_function_name (struct work_stuff *, const char **, string *,
+ const char *);
static int
-iterate_demangle_function PARAMS ((struct work_stuff *,
- const char **, string *, const char *));
+iterate_demangle_function (struct work_stuff *,
+ const char **, string *, const char *);
-static void
-remember_type PARAMS ((struct work_stuff *, const char *, int));
+static void remember_type (struct work_stuff *, const char *, int);
-static void
-remember_Btype PARAMS ((struct work_stuff *, const char *, int, int));
+static void remember_Btype (struct work_stuff *, const char *, int, int);
-static int
-register_Btype PARAMS ((struct work_stuff *));
+static int register_Btype (struct work_stuff *);
-static void
-remember_Ktype PARAMS ((struct work_stuff *, const char *, int));
+static void remember_Ktype (struct work_stuff *, const char *, int);
-static void
-forget_types PARAMS ((struct work_stuff *));
+static void forget_types (struct work_stuff *);
-static void
-forget_B_and_K_types PARAMS ((struct work_stuff *));
+static void forget_B_and_K_types (struct work_stuff *);
-static void
-string_prepends PARAMS ((string *, string *));
+static void string_prepends (string *, string *);
static int
-demangle_template_value_parm PARAMS ((struct work_stuff*, const char**,
- string*, type_kind_t));
+demangle_template_value_parm (struct work_stuff*, const char**,
+ string*, type_kind_t);
static int
-do_hpacc_template_const_value PARAMS ((struct work_stuff *, const char **, string *));
+do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
static int
-do_hpacc_template_literal PARAMS ((struct work_stuff *, const char **, string *));
+do_hpacc_template_literal (struct work_stuff *, const char **, string *);
-static int
-snarf_numeric_literal PARAMS ((const char **, string *));
+static int snarf_numeric_literal (const char **, string *);
/* There is a TYPE_QUAL value for each type qualifier. They can be
combined by bitwise-or to form the complete set of qualifiers for a
#define TYPE_QUAL_VOLATILE 0x2
#define TYPE_QUAL_RESTRICT 0x4
-static int
-code_for_qualifier PARAMS ((int));
+static int code_for_qualifier (int);
-static const char*
-qualifier_string PARAMS ((int));
+static const char* qualifier_string (int);
-static const char*
-demangle_qualifier PARAMS ((int));
+static const char* demangle_qualifier (int);
-static int
-demangle_expression PARAMS ((struct work_stuff *, const char **, string *,
- type_kind_t));
+static int demangle_expression (struct work_stuff *, const char **, string *,
+ type_kind_t);
static int
-demangle_integral_value PARAMS ((struct work_stuff *, const char **,
- string *));
+demangle_integral_value (struct work_stuff *, const char **, string *);
static int
-demangle_real_value PARAMS ((struct work_stuff *, const char **, string *));
+demangle_real_value (struct work_stuff *, const char **, string *);
static void
-demangle_arm_hp_template PARAMS ((struct work_stuff *, const char **, int,
- string *));
+demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
static void
-recursively_demangle PARAMS ((struct work_stuff *, const char **, string *,
- int));
+recursively_demangle (struct work_stuff *, const char **, string *, int);
-static void
-grow_vect PARAMS ((char **, size_t *, size_t, int));
+static void grow_vect (char **, size_t *, size_t, int);
/* Translate count to integer, consuming tokens in the process.
Conversion terminates on the first non-digit character.
Overflow consumes the rest of the digits, and returns -1. */
static int
-consume_count (type)
- const char **type;
+consume_count (const char **type)
{
int count = 0;
failure, since 0 can be a valid value. */
static int
-consume_count_with_underscores (mangled)
- const char **mangled;
+consume_count_with_underscores (const char **mangled)
{
int idx;
corresponding to this qualifier. */
static int
-code_for_qualifier (c)
- int c;
+code_for_qualifier (int c)
{
switch (c)
{
TYPE_QUALS. */
static const char*
-qualifier_string (type_quals)
- int type_quals;
+qualifier_string (int type_quals)
{
switch (type_quals)
{
called with a valid qualifier code. */
static const char*
-demangle_qualifier (c)
- int c;
+demangle_qualifier (int c)
{
return qualifier_string (code_for_qualifier (c));
}
int
-cplus_demangle_opname (opname, result, options)
- const char *opname;
- char *result;
- int options;
+cplus_demangle_opname (const char *opname, char *result, int options)
{
int len, len1, ret;
string type;
if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
const char *
-cplus_mangle_opname (opname, options)
- const char *opname;
- int options;
+cplus_mangle_opname (const char *opname, int options)
{
size_t i;
int len;
allow for any demangler initialization that maybe necessary. */
enum demangling_styles
-cplus_demangle_set_style (style)
- enum demangling_styles style;
+cplus_demangle_set_style (enum demangling_styles style)
{
const struct demangler_engine *demangler = libiberty_demanglers;
/* Do string name to style translation */
enum demangling_styles
-cplus_demangle_name_to_style (name)
- const char *name;
+cplus_demangle_name_to_style (const char *name)
{
const struct demangler_engine *demangler = libiberty_demanglers;
MANGLED. */
char *
-cplus_demangle (mangled, options)
- const char *mangled;
- int options;
+cplus_demangle (const char *mangled, int options)
{
char *ret;
struct work_stuff work[1];
updating *OLD_VECT and *SIZE as necessary. */
static void
-grow_vect (old_vect, size, min_size, element_size)
- char **old_vect;
- size_t *size;
- size_t min_size;
- int element_size;
+grow_vect (char **old_vect, size_t *size, size_t min_size, int element_size)
{
if (*size < min_size)
{
The resulting string is valid until the next call of ada_demangle. */
static char *
-ada_demangle (mangled, option)
- const char *mangled;
- int option ATTRIBUTE_UNUSED;
+ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
{
int i, j;
int len0;
calls go directly to this routine to avoid resetting that info. */
static char *
-internal_cplus_demangle (work, mangled)
- struct work_stuff *work;
- const char *mangled;
+internal_cplus_demangle (struct work_stuff *work, const char *mangled)
{
string decl;
/* Clear out and squangling related storage */
static void
-squangle_mop_up (work)
- struct work_stuff *work;
+squangle_mop_up (struct work_stuff *work)
{
/* clean up the B and K type mangling types. */
forget_B_and_K_types (work);
/* Copy the work state and storage. */
static void
-work_stuff_copy_to_from (to, from)
- struct work_stuff *to;
- struct work_stuff *from;
+work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
{
int i;
/* Delete dynamic stuff in work_stuff that is not to be re-used. */
static void
-delete_non_B_K_work_stuff (work)
- struct work_stuff *work;
+delete_non_B_K_work_stuff (struct work_stuff *work)
{
/* Discard the remembered types, if any. */
/* Delete all dynamic storage in work_stuff. */
static void
-delete_work_stuff (work)
- struct work_stuff *work;
+delete_work_stuff (struct work_stuff *work)
{
delete_non_B_K_work_stuff (work);
squangle_mop_up (work);
/* Clear out any mangled storage */
static char *
-mop_up (work, declp, success)
- struct work_stuff *work;
- string *declp;
- int success;
+mop_up (struct work_stuff *work, string *declp, int success)
{
char *demangled = NULL;
argument list. */
static int
-demangle_signature (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_signature (struct work_stuff *work,
+ const char **mangled, string *declp)
{
int success = 1;
int func_done = 0;
#if 0
static int
-demangle_method_args (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_method_args (struct work_stuff *work, const char **mangled,
+ string *declp)
{
int success = 0;
#endif
static int
-demangle_template_template_parm (work, mangled, tname)
- struct work_stuff *work;
- const char **mangled;
- string *tname;
+demangle_template_template_parm (struct work_stuff *work,
+ const char **mangled, string *tname)
{
int i;
int r;
}
static int
-demangle_expression (work, mangled, s, tk)
- struct work_stuff *work;
- const char** mangled;
- string* s;
- type_kind_t tk;
+demangle_expression (struct work_stuff *work, const char **mangled,
+ string *s, type_kind_t tk)
{
int need_operator = 0;
int success;
}
static int
-demangle_integral_value (work, mangled, s)
- struct work_stuff *work;
- const char** mangled;
- string* s;
+demangle_integral_value (struct work_stuff *work,
+ const char **mangled, string *s)
{
int success;
/* Demangle the real value in MANGLED. */
static int
-demangle_real_value (work, mangled, s)
- struct work_stuff *work;
- const char **mangled;
- string* s;
+demangle_real_value (struct work_stuff *work,
+ const char **mangled, string *s)
{
if (**mangled == 'E')
return demangle_expression (work, mangled, s, tk_real);
}
static int
-demangle_template_value_parm (work, mangled, s, tk)
- struct work_stuff *work;
- const char **mangled;
- string* s;
- type_kind_t tk;
+demangle_template_value_parm (struct work_stuff *work, const char **mangled,
+ string *s, type_kind_t tk)
{
int success = 1;
types. */
static int
-demangle_template (work, mangled, tname, trawname, is_type, remember)
- struct work_stuff *work;
- const char **mangled;
- string *tname;
- string *trawname;
- int is_type;
- int remember;
+demangle_template (struct work_stuff *work, const char **mangled,
+ string *tname, string *trawname,
+ int is_type, int remember)
{
int i;
int r;
}
static int
-arm_pt (work, mangled, n, anchor, args)
- struct work_stuff *work;
- const char *mangled;
- int n;
- const char **anchor, **args;
+arm_pt (struct work_stuff *work, const char *mangled,
+ int n, const char **anchor, const char **args)
{
/* Check if ARM template with "__pt__" in it ("parameterized type") */
/* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
}
static void
-demangle_arm_hp_template (work, mangled, n, declp)
- struct work_stuff *work;
- const char **mangled;
- int n;
- string *declp;
+demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
+ int n, string *declp)
{
const char *p;
const char *args;
already been dealt with */
static int
-demangle_class_name (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_class_name (struct work_stuff *work, const char **mangled,
+ string *declp)
{
int n;
int success = 0;
*/
static int
-demangle_class (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_class (struct work_stuff *work, const char **mangled, string *declp)
{
int success = 0;
int btype;
demangle_signature. */
static int
-iterate_demangle_function (work, mangled, declp, scan)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
- const char *scan;
+iterate_demangle_function (struct work_stuff *work, const char **mangled,
+ string *declp, const char *scan)
{
const char *mangle_init = *mangled;
int success = 0;
*/
static int
-demangle_prefix (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_prefix (struct work_stuff *work, const char **mangled,
+ string *declp)
{
int success = 1;
const char *scan;
*/
static int
-gnu_special (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+gnu_special (struct work_stuff *work, const char **mangled, string *declp)
{
int n;
int success = 1;
}
static void
-recursively_demangle(work, mangled, result, namelength)
- struct work_stuff *work;
- const char **mangled;
- string *result;
- int namelength;
+recursively_demangle(struct work_stuff *work, const char **mangled,
+ string *result, int namelength)
{
char * recurse = (char *)NULL;
char * recurse_dem = (char *)NULL;
*/
static int
-arm_special (mangled, declp)
- const char **mangled;
- string *declp;
+arm_special (const char **mangled, string *declp)
{
int n;
int success = 1;
*/
static int
-demangle_qualified (work, mangled, result, isfuncname, append)
- struct work_stuff *work;
- const char **mangled;
- string *result;
- int isfuncname;
- int append;
+demangle_qualified (struct work_stuff *work, const char **mangled,
+ string *result, int isfuncname, int append)
{
int qualifiers = 0;
int success = 1;
*/
static int
-get_count (type, count)
- const char **type;
- int *count;
+get_count (const char **type, int *count)
{
const char *p;
int n;
value returned is really a type_kind_t. */
static int
-do_type (work, mangled, result)
- struct work_stuff *work;
- const char **mangled;
- string *result;
+do_type (struct work_stuff *work, const char **mangled, string *result)
{
int n;
int done;
The value returned is really a type_kind_t. */
static int
-demangle_fund_type (work, mangled, result)
- struct work_stuff *work;
- const char **mangled;
- string *result;
+demangle_fund_type (struct work_stuff *work,
+ const char **mangled, string *result)
{
int done = 0;
int success = 1;
**mangled points to 'S' or 'U' */
static int
-do_hpacc_template_const_value (work, mangled, result)
- struct work_stuff *work ATTRIBUTE_UNUSED;
- const char **mangled;
- string *result;
+do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
+ const char **mangled, string *result)
{
int unsigned_const;
**mangled is pointing to the 'A' */
static int
-do_hpacc_template_literal (work, mangled, result)
- struct work_stuff *work;
- const char **mangled;
- string *result;
+do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
+ string *result)
{
int literal_len = 0;
char * recurse;
}
static int
-snarf_numeric_literal (args, arg)
- const char ** args;
- string * arg;
+snarf_numeric_literal (const char **args, string *arg)
{
if (**args == '-')
{
and free'd should anything go wrong. */
static int
-do_arg (work, mangled, result)
- struct work_stuff *work;
- const char **mangled;
- string *result;
+do_arg (struct work_stuff *work, const char **mangled, string *result)
{
/* Remember where we started so that we can record the type, for
non-squangling type remembering. */
}
static void
-remember_type (work, start, len)
- struct work_stuff *work;
- const char *start;
- int len;
+remember_type (struct work_stuff *work, const char *start, int len)
{
char *tem;
/* Remember a K type class qualifier. */
static void
-remember_Ktype (work, start, len)
- struct work_stuff *work;
- const char *start;
- int len;
+remember_Ktype (struct work_stuff *work, const char *start, int len)
{
char *tem;
registers map<temp<char> > as B0, and temp<char> as B1 */
static int
-register_Btype (work)
- struct work_stuff *work;
+register_Btype (struct work_stuff *work)
{
int ret;
/* Store a value into a previously registered B code type. */
static void
-remember_Btype (work, start, len, index)
- struct work_stuff *work;
- const char *start;
- int len, index;
+remember_Btype (struct work_stuff *work, const char *start,
+ int len, int index)
{
char *tem;
/* Lose all the info related to B and K type codes. */
static void
-forget_B_and_K_types (work)
- struct work_stuff *work;
+forget_B_and_K_types (struct work_stuff *work)
{
int i;
/* Forget the remembered types, but not the type vector itself. */
static void
-forget_types (work)
- struct work_stuff *work;
+forget_types (struct work_stuff *work)
{
int i;
*/
static int
-demangle_args (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_args (struct work_stuff *work, const char **mangled,
+ string *declp)
{
string arg;
int need_comma = 0;
and method pointers or references, not top-level declarations. */
static int
-demangle_nested_args (work, mangled, declp)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
+demangle_nested_args (struct work_stuff *work, const char **mangled,
+ string *declp)
{
string* saved_previous_argument;
int result;
}
static void
-demangle_function_name (work, mangled, declp, scan)
- struct work_stuff *work;
- const char **mangled;
- string *declp;
- const char *scan;
+demangle_function_name (struct work_stuff *work, const char **mangled,
+ string *declp, const char *scan)
{
size_t i;
string type;
/* a mini string-handling package */
static void
-string_need (s, n)
- string *s;
- int n;
+string_need (string *s, int n)
{
int tem;
}
static void
-string_delete (s)
- string *s;
+string_delete (string *s)
{
if (s->b != NULL)
{
}
static void
-string_init (s)
- string *s;
+string_init (string *s)
{
s->b = s->p = s->e = NULL;
}
static void
-string_clear (s)
- string *s;
+string_clear (string *s)
{
s->p = s->b;
}
#if 0
static int
-string_empty (s)
- string *s;
+string_empty (string *s)
{
return (s->b == s->p);
}
#endif
static void
-string_append (p, s)
- string *p;
- const char *s;
+string_append (string *p, const char *s)
{
int n;
if (s == NULL || *s == '\0')
}
static void
-string_appends (p, s)
- string *p, *s;
+string_appends (string *p, string *s)
{
int n;
}
static void
-string_appendn (p, s, n)
- string *p;
- const char *s;
- int n;
+string_appendn (string *p, const char *s, int n)
{
if (n != 0)
{
}
static void
-string_prepend (p, s)
- string *p;
- const char *s;
+string_prepend (string *p, const char *s)
{
if (s != NULL && *s != '\0')
{
}
static void
-string_prepends (p, s)
- string *p, *s;
+string_prepends (string *p, string *s)
{
if (s->b != s->p)
{
}
static void
-string_prependn (p, s, n)
- string *p;
- const char *s;
- int n;
+string_prependn (string *p, const char *s, int n)
{
char *q;
}
static void
-string_append_template_idx (s, idx)
- string *s;
- int idx;
+string_append_template_idx (string *s, int idx)
{
char buf[INTBUF_SIZE + 1 /* 'T' */];
sprintf(buf, "T%d", idx);
projects / binutils-gdb.git / commitdiff