#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);