Re: [gcc patch 1/3] cp-demangle.c: Make `options' a parameter

Jan Kratochvil
2011-06-13T22:37:18Z

On Mon, 13 Jun 2011 20:06:21 +0200, Ian Lance Taylor wrote:
> The new options parameter should be the second parameter, not the last.

OK, I agree.

> This is OK with those changes.

Checked in.

Thanks,
Jan

http://gcc.gnu.org/viewcvs?view=revision&revision=174999

--- trunk/libiberty/ChangeLog 2011/06/13 19:05:04 174998
+++ trunk/libiberty/ChangeLog 2011/06/13 22:30:02 174999
@@ -1,3 +1,12 @@
+2011-06-13 Jan Kratochvil <jan.kratochvil@redhat.com>
+
+ * cp-demangle.c (struct d_print_info): Remove field options.
+ (d_print_init): Remove parameter options.
+ (cplus_demangle_print_callback): Update all the callers.
+ (d_print_comp, d_print_mod_list, d_print_mod, d_print_function_type)
+ (d_print_array_type, d_print_expr_op, d_print_cast, d_print_subexpr):
+ Add parameter options, update all the callers.
+
2011-04-20 Jim Meyering <meyering@redhat.com>

* cp-demint.c (cplus_demangle_v3_components): Remove useless
--- trunk/libiberty/cp-demangle.c 2011/06/13 19:05:04 174998
+++ trunk/libiberty/cp-demangle.c 2011/06/13 22:30:02 174999
@@ -278,8 +278,6 @@
enum { D_PRINT_BUFFER_LENGTH = 256 };
struct d_print_info
{
- /* The options passed to the demangler. */
- int options;
/* Fixed-length allocated buffer for demangled data, flushed to the
callback with a NUL termination once full. */
char buf[D_PRINT_BUFFER_LENGTH];
@@ -436,7 +434,7 @@
d_growable_string_callback_adapter (const char *, size_t, void *);

static void
-d_print_init (struct d_print_info *, int, demangle_callbackref, void *);
+d_print_init (struct d_print_info *, demangle_callbackref, void *);

static inline void d_print_error (struct d_print_info *);

@@ -454,32 +452,32 @@
static inline char d_last_char (struct d_print_info *);

static void
-d_print_comp (struct d_print_info *, const struct demangle_component *);
+d_print_comp (struct d_print_info *, int, const struct demangle_component *);

static void
d_print_java_identifier (struct d_print_info *, const char *, int);

static void
-d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
+d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);

static void
-d_print_mod (struct d_print_info *, const struct demangle_component *);
+d_print_mod (struct d_print_info *, int, const struct demangle_component *);

static void
-d_print_function_type (struct d_print_info *,
+d_print_function_type (struct d_print_info *, int,
const struct demangle_component *,
struct d_print_mod *);

static void
-d_print_array_type (struct d_print_info *,
+d_print_array_type (struct d_print_info *, int,
const struct demangle_component *,
struct d_print_mod *);

static void
-d_print_expr_op (struct d_print_info *, const struct demangle_component *);
+d_print_expr_op (struct d_print_info *, int, const struct demangle_component *);

static void
-d_print_cast (struct d_print_info *, const struct demangle_component *);
+d_print_cast (struct d_print_info *, int, const struct demangle_component *);

static int d_demangle_callback (const char *, int,
demangle_callbackref, void *);
@@ -3293,10 +3291,9 @@
/* Initialize a print information structure. */

static void
-d_print_init (struct d_print_info *dpi, int options,
- demangle_callbackref callback, void *opaque)
+d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
+ void *opaque)
{
- dpi->options = options;
dpi->len = 0;
dpi->last_char = '\0';
dpi->templates = NULL;
@@ -3392,9 +3389,9 @@
{
struct d_print_info dpi;

- d_print_init (&dpi, options, callback, opaque);
+ d_print_init (&dpi, callback, opaque);

- d_print_comp (&dpi, dc);
+ d_print_comp (&dpi, options, dc);

d_print_flush (&dpi);

@@ -3537,7 +3534,7 @@
if needed. */

static void
-d_print_subexpr (struct d_print_info *dpi,
+d_print_subexpr (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
int simple = 0;
@@ -3546,7 +3543,7 @@
simple = 1;
if (!simple)
d_append_char (dpi, '(');
- d_print_comp (dpi, dc);
+ d_print_comp (dpi, options, dc);
if (!simple)
d_append_char (dpi, ')');
}
@@ -3554,7 +3551,7 @@
/* Subroutine to handle components. */

static void
-d_print_comp (struct d_print_info *dpi,
+d_print_comp (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (dc == NULL)
@@ -3568,7 +3565,7 @@
switch (dc->type)
{
case DEMANGLE_COMPONENT_NAME:
- if ((dpi->options & DMGL_JAVA) == 0)
+ if ((options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
else
d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
@@ -3576,12 +3573,12 @@

case DEMANGLE_COMPONENT_QUAL_NAME:
case DEMANGLE_COMPONENT_LOCAL_NAME:
- d_print_comp (dpi, d_left (dc));
- if ((dpi->options & DMGL_JAVA) == 0)
+ d_print_comp (dpi, options, d_left (dc));
+ if ((options & DMGL_JAVA) == 0)
d_append_string (dpi, "::");
else
d_append_char (dpi, '.');
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
return;

case DEMANGLE_COMPONENT_TYPED_NAME:
@@ -3671,7 +3668,7 @@
}
}

- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));

if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
dpi->templates = dpt.next;
@@ -3684,7 +3681,7 @@
if (! adpm[i].printed)
{
d_append_char (dpi, ' ');
- d_print_mod (dpi, adpm[i].mod);
+ d_print_mod (dpi, options, adpm[i].mod);
}
}

@@ -3707,7 +3704,7 @@

dcl = d_left (dc);

- if ((dpi->options & DMGL_JAVA) != 0
+ if ((options & DMGL_JAVA) != 0
&& dcl->type == DEMANGLE_COMPONENT_NAME
&& dcl->u.s_name.len == 6
&& strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
@@ -3715,16 +3712,16 @@
/* Special-case Java arrays, so that JArray<TYPE> appears
instead as TYPE[]. */

- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
d_append_string (dpi, "[]");
}
else
{
- d_print_comp (dpi, dcl);
+ d_print_comp (dpi, options, dcl);
if (d_last_char (dpi) == '<')
d_append_char (dpi, ' ');
d_append_char (dpi, '<');
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
if (d_last_char (dpi) == '>')
@@ -3759,7 +3756,7 @@
hold_dpt = dpi->templates;
dpi->templates = hold_dpt->next;

- d_print_comp (dpi, a);
+ d_print_comp (dpi, options, a);

dpi->templates = hold_dpt;

@@ -3767,79 +3764,79 @@
}

case DEMANGLE_COMPONENT_CTOR:
- d_print_comp (dpi, dc->u.s_ctor.name);
+ d_print_comp (dpi, options, dc->u.s_ctor.name);
return;

case DEMANGLE_COMPONENT_DTOR:
d_append_char (dpi, '~');
- d_print_comp (dpi, dc->u.s_dtor.name);
+ d_print_comp (dpi, options, dc->u.s_dtor.name);
return;

case DEMANGLE_COMPONENT_VTABLE:
d_append_string (dpi, "vtable for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_VTT:
d_append_string (dpi, "VTT for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
d_append_string (dpi, "construction vtable for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
d_append_string (dpi, "-in-");
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
return;

case DEMANGLE_COMPONENT_TYPEINFO:
d_append_string (dpi, "typeinfo for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_TYPEINFO_NAME:
d_append_string (dpi, "typeinfo name for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_TYPEINFO_FN:
d_append_string (dpi, "typeinfo fn for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_THUNK:
d_append_string (dpi, "non-virtual thunk to ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
d_append_string (dpi, "virtual thunk to ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_COVARIANT_THUNK:
d_append_string (dpi, "covariant return thunk to ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_JAVA_CLASS:
d_append_string (dpi, "java Class for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_GUARD:
d_append_string (dpi, "guard variable for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_REFTEMP:
d_append_string (dpi, "reference temporary for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
d_append_string (dpi, "hidden alias for ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_SUB_STD:
@@ -3866,7 +3863,7 @@
break;
if (pdpm->mod->type == dc->type)
{
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;
}
}
@@ -3892,12 +3889,12 @@
dpm.printed = 0;
dpm.templates = dpi->templates;

- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));

/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
- d_print_mod (dpi, dc);
+ d_print_mod (dpi, options, dc);

dpi->modifiers = dpm.next;

@@ -3905,7 +3902,7 @@
}

case DEMANGLE_COMPONENT_BUILTIN_TYPE:
- if ((dpi->options & DMGL_JAVA) == 0)
+ if ((options & DMGL_JAVA) == 0)
d_append_buffer (dpi, dc->u.s_builtin.type->name,
dc->u.s_builtin.type->len);
else
@@ -3914,13 +3911,13 @@
return;

case DEMANGLE_COMPONENT_VENDOR_TYPE:
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_FUNCTION_TYPE:
{
- if ((dpi->options & DMGL_RET_POSTFIX) != 0)
- d_print_function_type (dpi, dc, dpi->modifiers);
+ if ((options & DMGL_RET_POSTFIX) != 0)
+ d_print_function_type (dpi, options, dc, dpi->modifiers);

/* Print return type if present */
if (d_left (dc) != NULL)
@@ -3935,7 +3932,7 @@
dpm.printed = 0;
dpm.templates = dpi->templates;

- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));

dpi->modifiers = dpm.next;

@@ -3944,12 +3941,12 @@

/* In standard prefix notation, there is a space between the
return type and the function signature. */
- if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+ if ((options & DMGL_RET_POSTFIX) == 0)
d_append_char (dpi, ' ');
}

- if ((dpi->options & DMGL_RET_POSTFIX) == 0)
- d_print_function_type (dpi, dc, dpi->modifiers);
+ if ((options & DMGL_RET_POSTFIX) == 0)
+ d_print_function_type (dpi, options, dc, dpi->modifiers);

return;
}
@@ -4002,7 +3999,7 @@
pdpm = pdpm->next;
}

- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));

dpi->modifiers = hold_modifiers;

@@ -4012,10 +4009,10 @@
while (i > 1)
{
--i;
- d_print_mod (dpi, adpm[i].mod);
+ d_print_mod (dpi, options, adpm[i].mod);
}

- d_print_array_type (dpi, dc, dpi->modifiers);
+ d_print_array_type (dpi, options, dc, dpi->modifiers);

return;
}
@@ -4031,12 +4028,12 @@
dpm.printed = 0;
dpm.templates = dpi->templates;

- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));

/* If the modifier didn't get printed by the type, print it
now. */
if (! dpm.printed)
- d_print_mod (dpi, dc);
+ d_print_mod (dpi, options, dc);

dpi->modifiers = dpm.next;

@@ -4050,7 +4047,7 @@
if (dc->u.s_fixed.length->u.s_builtin.type
!= &cplus_demangle_builtin_types['i'-'a'])
{
- d_print_comp (dpi, dc->u.s_fixed.length);
+ d_print_comp (dpi, options, dc->u.s_fixed.length);
d_append_char (dpi, ' ');
}
if (dc->u.s_fixed.accum)
@@ -4062,7 +4059,7 @@
case DEMANGLE_COMPONENT_ARGLIST:
case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
if (d_left (dc) != NULL)
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
if (d_right (dc) != NULL)
{
size_t len;
@@ -4074,7 +4071,7 @@
d_append_string (dpi, ", ");
len = dpi->len;
flush_count = dpi->flush_count;
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
/* If that didn't print anything (which can happen with empty
template argument packs), remove the comma and space. */
if (dpi->flush_count == flush_count && dpi->len == len)
@@ -4097,24 +4094,24 @@

case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d_append_string (dpi, "operator ");
- d_print_comp (dpi, dc->u.s_extended_operator.name);
+ d_print_comp (dpi, options, dc->u.s_extended_operator.name);
return;

case DEMANGLE_COMPONENT_CAST:
d_append_string (dpi, "operator ");
- d_print_cast (dpi, dc);
+ d_print_cast (dpi, options, dc);
return;

case DEMANGLE_COMPONENT_UNARY:
if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
- d_print_expr_op (dpi, d_left (dc));
+ d_print_expr_op (dpi, options, d_left (dc));
else
{
d_append_char (dpi, '(');
- d_print_cast (dpi, d_left (dc));
+ d_print_cast (dpi, options, d_left (dc));
d_append_char (dpi, ')');
}
- d_print_subexpr (dpi, d_right (dc));
+ d_print_subexpr (dpi, options, d_right (dc));
return;

case DEMANGLE_COMPONENT_BINARY:
@@ -4132,18 +4129,18 @@
&& d_left (dc)->u.s_operator.op->name[0] == '>')
d_append_char (dpi, '(');

- d_print_subexpr (dpi, d_left (d_right (dc)));
+ d_print_subexpr (dpi, options, d_left (d_right (dc)));
if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
{
d_append_char (dpi, '[');
- d_print_comp (dpi, d_right (d_right (dc)));
+ d_print_comp (dpi, options, d_right (d_right (dc)));
d_append_char (dpi, ']');
}
else
{
if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
- d_print_expr_op (dpi, d_left (dc));
- d_print_subexpr (dpi, d_right (d_right (dc)));
+ d_print_expr_op (dpi, options, d_left (dc));
+ d_print_subexpr (dpi, options, d_right (d_right (dc)));
}

if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
@@ -4165,11 +4162,11 @@
d_print_error (dpi);
return;
}
- d_print_subexpr (dpi, d_left (d_right (dc)));
- d_print_expr_op (dpi, d_left (dc));
- d_print_subexpr (dpi, d_left (d_right (d_right (dc))));
+ d_print_subexpr (dpi, options, d_left (d_right (dc)));
+ d_print_expr_op (dpi, options, d_left (dc));
+ d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
d_append_string (dpi, " : ");
- d_print_subexpr (dpi, d_right (d_right (d_right (dc))));
+ d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
return;

case DEMANGLE_COMPONENT_TRINARY_ARG1:
@@ -4200,7 +4197,7 @@
{
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
switch (tp)
{
default:
@@ -4250,13 +4247,13 @@
}

d_append_char (dpi, '(');
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
d_append_char (dpi, ')');
if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
d_append_char (dpi, '-');
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, '[');
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));
if (tp == D_PRINT_FLOAT)
d_append_char (dpi, ']');
}
@@ -4268,12 +4265,12 @@

case DEMANGLE_COMPONENT_JAVA_RESOURCE:
d_append_string (dpi, "java resource ");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
return;

case DEMANGLE_COMPONENT_COMPOUND_NAME:
- d_print_comp (dpi, d_left (dc));
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_left (dc));
+ d_print_comp (dpi, options, d_right (dc));
return;

case DEMANGLE_COMPONENT_CHARACTER:
@@ -4282,7 +4279,7 @@

case DEMANGLE_COMPONENT_DECLTYPE:
d_append_string (dpi, "decltype (");
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
d_append_char (dpi, ')');
return;

@@ -4296,7 +4293,7 @@
/* d_find_pack won't find anything if the only packs involved
in this expansion are function parameter packs; in that
case, just print the pattern and "...". */
- d_print_subexpr (dpi, d_left (dc));
+ d_print_subexpr (dpi, options, d_left (dc));
d_append_string (dpi, "...");
return;
}
@@ -4306,7 +4303,7 @@
for (i = 0; i < len; ++i)
{
dpi->pack_index = i;
- d_print_comp (dpi, dc);
+ d_print_comp (dpi, options, dc);
if (i < len-1)
d_append_string (dpi, ", ");
}
@@ -4321,17 +4318,17 @@

case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
d_append_string (dpi, "global constructors keyed to ");
- d_print_comp (dpi, dc->u.s_binary.left);
+ d_print_comp (dpi, options, dc->u.s_binary.left);
return;

case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
d_append_string (dpi, "global destructors keyed to ");
- d_print_comp (dpi, dc->u.s_binary.left);
+ d_print_comp (dpi, options, dc->u.s_binary.left);
return;

case DEMANGLE_COMPONENT_LAMBDA:
d_append_string (dpi, "{lambda(");
- d_print_comp (dpi, dc->u.s_unary_num.sub);
+ d_print_comp (dpi, options, dc->u.s_unary_num.sub);
d_append_string (dpi, ")#");
d_append_num (dpi, dc->u.s_unary_num.num + 1);
d_append_char (dpi, '}');
@@ -4405,7 +4402,7 @@
qualifiers on this after printing a function. */

static void
-d_print_mod_list (struct d_print_info *dpi,
+d_print_mod_list (struct d_print_info *dpi, int options,
struct d_print_mod *mods, int suffix)
{
struct d_print_template *hold_dpt;
@@ -4419,7 +4416,7 @@
|| mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
|| mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
{
- d_print_mod_list (dpi, mods->next, suffix);
+ d_print_mod_list (dpi, options, mods->next, suffix);
return;
}

@@ -4430,13 +4427,13 @@

if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
{
- d_print_function_type (dpi, mods->mod, mods->next);
+ d_print_function_type (dpi, options, mods->mod, mods->next);
dpi->templates = hold_dpt;
return;
}
else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
{
- d_print_array_type (dpi, mods->mod, mods->next);
+ d_print_array_type (dpi, options, mods->mod, mods->next);
dpi->templates = hold_dpt;
return;
}
@@ -4452,10 +4449,10 @@

hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;
- d_print_comp (dpi, d_left (mods->mod));
+ d_print_comp (dpi, options, d_left (mods->mod));
dpi->modifiers = hold_modifiers;

- if ((dpi->options & DMGL_JAVA) == 0)
+ if ((options & DMGL_JAVA) == 0)
d_append_string (dpi, "::");
else
d_append_char (dpi, '.');
@@ -4475,23 +4472,23 @@
|| dc->type == DEMANGLE_COMPONENT_CONST_THIS)
dc = d_left (dc);

- d_print_comp (dpi, dc);
+ d_print_comp (dpi, options, dc);

dpi->templates = hold_dpt;
return;
}

- d_print_mod (dpi, mods->mod);
+ d_print_mod (dpi, options, mods->mod);

dpi->templates = hold_dpt;

- d_print_mod_list (dpi, mods->next, suffix);
+ d_print_mod_list (dpi, options, mods->next, suffix);
}

/* Print a modifier. */

static void
-d_print_mod (struct d_print_info *dpi,
+d_print_mod (struct d_print_info *dpi, int options,
const struct demangle_component *mod)
{
switch (mod->type)
@@ -4510,11 +4507,11 @@
return;
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d_append_char (dpi, ' ');
- d_print_comp (dpi, d_right (mod));
+ d_print_comp (dpi, options, d_right (mod));
return;
case DEMANGLE_COMPONENT_POINTER:
/* There is no pointer symbol in Java. */
- if ((dpi->options & DMGL_JAVA) == 0)
+ if ((options & DMGL_JAVA) == 0)
d_append_char (dpi, '*');
return;
case DEMANGLE_COMPONENT_REFERENCE:
@@ -4532,22 +4529,22 @@
case DEMANGLE_COMPONENT_PTRMEM_TYPE:
if (d_last_char (dpi) != '(')
d_append_char (dpi, ' ');
- d_print_comp (dpi, d_left (mod));
+ d_print_comp (dpi, options, d_left (mod));
d_append_string (dpi, "::*");
return;
case DEMANGLE_COMPONENT_TYPED_NAME:
- d_print_comp (dpi, d_left (mod));
+ d_print_comp (dpi, options, d_left (mod));
return;
case DEMANGLE_COMPONENT_VECTOR_TYPE:
d_append_string (dpi, " __vector(");
- d_print_comp (dpi, d_left (mod));
+ d_print_comp (dpi, options, d_left (mod));
d_append_char (dpi, ')');
return;

default:
/* Otherwise, we have something that won't go back on the
modifier stack, so we can just print it. */
- d_print_comp (dpi, mod);
+ d_print_comp (dpi, options, mod);
return;
}
}
@@ -4555,7 +4552,7 @@
/* Print a function type, except for the return type. */

static void
-d_print_function_type (struct d_print_info *dpi,
+d_print_function_type (struct d_print_info *dpi, int options,
const struct demangle_component *dc,
struct d_print_mod *mods)
{
@@ -4615,7 +4612,7 @@
hold_modifiers = dpi->modifiers;
dpi->modifiers = NULL;

- d_print_mod_list (dpi, mods, 0);
+ d_print_mod_list (dpi, options, mods, 0);

if (need_paren)
d_append_char (dpi, ')');
@@ -4623,11 +4620,11 @@
d_append_char (dpi, '(');

if (d_right (dc) != NULL)
- d_print_comp (dpi, d_right (dc));
+ d_print_comp (dpi, options, d_right (dc));

d_append_char (dpi, ')');

- d_print_mod_list (dpi, mods, 1);
+ d_print_mod_list (dpi, options, mods, 1);

dpi->modifiers = hold_modifiers;
}
@@ -4635,7 +4632,7 @@
/* Print an array type, except for the element type. */

static void
-d_print_array_type (struct d_print_info *dpi,
+d_print_array_type (struct d_print_info *dpi, int options,
const struct demangle_component *dc,
struct d_print_mod *mods)
{
@@ -4669,7 +4666,7 @@
if (need_paren)
d_append_string (dpi, " (");

- d_print_mod_list (dpi, mods, 0);
+ d_print_mod_list (dpi, options, mods, 0);

if (need_paren)
d_append_char (dpi, ')');
@@ -4681,7 +4678,7 @@
d_append_char (dpi, '[');

if (d_left (dc) != NULL)
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));

d_append_char (dpi, ']');
}
@@ -4689,24 +4686,24 @@
/* Print an operator in an expression. */

static void
-d_print_expr_op (struct d_print_info *dpi,
+d_print_expr_op (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
d_append_buffer (dpi, dc->u.s_operator.op->name,
dc->u.s_operator.op->len);
else
- d_print_comp (dpi, dc);
+ d_print_comp (dpi, options, dc);
}

/* Print a cast. */

static void
-d_print_cast (struct d_print_info *dpi,
+d_print_cast (struct d_print_info *dpi, int options,
const struct demangle_component *dc)
{
if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
- d_print_comp (dpi, d_left (dc));
+ d_print_comp (dpi, options, d_left (dc));
else
{
struct d_print_mod *hold_dpm;
@@ -4724,14 +4721,14 @@
dpi->templates = &dpt;
dpt.template_decl = d_left (dc);

- d_print_comp (dpi, d_left (d_left (dc)));
+ d_print_comp (dpi, options, d_left (d_left (dc)));

dpi->templates = dpt.next;

if (d_last_char (dpi) == '<')
d_append_char (dpi, ' ');
d_append_char (dpi, '<');
- d_print_comp (dpi, d_right (d_left (dc)));
+ d_print_comp (dpi, options, d_right (d_left (dc)));
/* Avoid generating two consecutive '>' characters, to avoid
the C++ syntactic ambiguity. */
if (d_last_char (dpi) == '>')