struct demangle_component comps[ALLOC_CHUNK];
};
+%}
+
+%union
+ {
+ struct demangle_component *comp;
+ struct nested {
+ struct demangle_component *comp;
+ struct demangle_component **last;
+ } nested;
+ struct {
+ struct demangle_component *comp, *last;
+ } nested1;
+ struct {
+ struct demangle_component *comp, **last;
+ struct nested fn;
+ struct demangle_component *start;
+ int fold_flag;
+ } abstract;
+ int lval;
+ const char *opname;
+ }
+
+%{
+
struct cpname_state
{
-/* LEXPTR is the current pointer into our lex buffer. PREV_LEXPTR
- is the start of the last token lexed, only used for diagnostics.
- ERROR_LEXPTR is the first place an error occurred. GLOBAL_ERRMSG
- is the first error message encountered. */
+ /* LEXPTR is the current pointer into our lex buffer. PREV_LEXPTR
+ is the start of the last token lexed, only used for diagnostics.
+ ERROR_LEXPTR is the first place an error occurred. GLOBAL_ERRMSG
+ is the first error message encountered. */
const char *lexptr, *prev_lexptr, *error_lexptr, *global_errmsg;
successful parse. */
struct demangle_component *global_result;
+
+ struct demangle_component *d_grab ();
+
+ /* Helper functions. These wrap the demangler tree interface,
+ handle allocation from our global store, and return the allocated
+ component. */
+
+ struct demangle_component *fill_comp (enum demangle_component_type d_type,
+ struct demangle_component *lhs,
+ struct demangle_component *rhs);
+
+ struct demangle_component *make_operator (const char *name, int args);
+
+ struct demangle_component *make_dtor (enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name);
+
+ struct demangle_component *make_builtin_type (const char *name);
+
+ struct demangle_component *make_name (const char *name, int len);
+
+ struct demangle_component *d_qualify (struct demangle_component *lhs,
+ int qualifiers, int is_method);
+
+ struct demangle_component *d_int_type (int flags);
+
+ struct demangle_component *d_unary (const char *name,
+ struct demangle_component *lhs);
+
+ struct demangle_component *d_binary (const char *name,
+ struct demangle_component *lhs,
+ struct demangle_component *rhs);
+
+ int parse_number (const char *p, int len, int parsed_float, YYSTYPE *lvalp);
};
-static struct demangle_component *
-d_grab (cpname_state *state)
+struct demangle_component *
+cpname_state::d_grab ()
{
struct demangle_info *more;
- if (state->demangle_info->used >= ALLOC_CHUNK)
+ if (demangle_info->used >= ALLOC_CHUNK)
{
- if (state->demangle_info->next == NULL)
+ if (demangle_info->next == NULL)
{
more = XNEW (struct demangle_info);
more->next = NULL;
- state->demangle_info->next = more;
+ demangle_info->next = more;
}
else
- more = state->demangle_info->next;
+ more = demangle_info->next;
more->used = 0;
- state->demangle_info = more;
+ demangle_info = more;
}
- return &state->demangle_info->comps[state->demangle_info->used++];
+ return &demangle_info->comps[demangle_info->used++];
}
-/* Prototypes for helper functions used when constructing the parse
- tree. */
-
-static struct demangle_component *d_qualify (cpname_state *state,
- struct demangle_component *, int,
- int);
-
-static struct demangle_component *d_int_type (cpname_state *state, int);
-
-static struct demangle_component *d_unary (cpname_state *state, const char *,
- struct demangle_component *);
-static struct demangle_component *d_binary (cpname_state *state, const char *,
- struct demangle_component *,
- struct demangle_component *);
-
/* Flags passed to d_qualify. */
#define QUAL_CONST 1
/* Helper functions. These wrap the demangler tree interface, handle
allocation from our global store, and return the allocated component. */
-static struct demangle_component *
-fill_comp (cpname_state *state,
- enum demangle_component_type d_type, struct demangle_component *lhs,
- struct demangle_component *rhs)
+struct demangle_component *
+cpname_state::fill_comp (enum demangle_component_type d_type,
+ struct demangle_component *lhs,
+ struct demangle_component *rhs)
{
- struct demangle_component *ret = d_grab (state);
+ struct demangle_component *ret = d_grab ();
int i;
i = cplus_demangle_fill_component (ret, d_type, lhs, rhs);
return ret;
}
-static struct demangle_component *
-make_operator (cpname_state *state, const char *name, int args)
+struct demangle_component *
+cpname_state::make_operator (const char *name, int args)
{
- struct demangle_component *ret = d_grab (state);
+ struct demangle_component *ret = d_grab ();
int i;
i = cplus_demangle_fill_operator (ret, name, args);
return ret;
}
-static struct demangle_component *
-make_dtor (cpname_state *state, enum gnu_v3_dtor_kinds kind,
- struct demangle_component *name)
+struct demangle_component *
+cpname_state::make_dtor (enum gnu_v3_dtor_kinds kind,
+ struct demangle_component *name)
{
- struct demangle_component *ret = d_grab (state);
+ struct demangle_component *ret = d_grab ();
int i;
i = cplus_demangle_fill_dtor (ret, kind, name);
return ret;
}
-static struct demangle_component *
-make_builtin_type (cpname_state *state, const char *name)
+struct demangle_component *
+cpname_state::make_builtin_type (const char *name)
{
- struct demangle_component *ret = d_grab (state);
+ struct demangle_component *ret = d_grab ();
int i;
i = cplus_demangle_fill_builtin_type (ret, name);
return ret;
}
-static struct demangle_component *
-make_name (cpname_state *state, const char *name, int len)
+struct demangle_component *
+cpname_state::make_name (const char *name, int len)
{
- struct demangle_component *ret = d_grab (state);
+ struct demangle_component *ret = d_grab ();
int i;
i = cplus_demangle_fill_name (ret, name, len);
#define d_left(dc) (dc)->u.s_binary.left
#define d_right(dc) (dc)->u.s_binary.right
-%}
-
-%union
- {
- struct demangle_component *comp;
- struct nested {
- struct demangle_component *comp;
- struct demangle_component **last;
- } nested;
- struct {
- struct demangle_component *comp, *last;
- } nested1;
- struct {
- struct demangle_component *comp, **last;
- struct nested fn;
- struct demangle_component *start;
- int fold_flag;
- } abstract;
- int lval;
- const char *opname;
- }
-
-%{
static int yylex (YYSTYPE *, cpname_state *);
static void yyerror (cpname_state *, const char *);
%}
start_opt is used to handle "function-local" variables and
types. */
| typespec_2 function_arglist start_opt
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME,
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME,
$1, $2.comp);
if ($3)
- $$ = fill_comp (state,
- DEMANGLE_COMPONENT_LOCAL_NAME,
- $$, $3);
+ $$ = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME,
+ $$, $3);
}
| colon_ext_only function_arglist start_opt
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
- if ($3) $$ = fill_comp (state, DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+ if ($3) $$ = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $3); }
| conversion_op_name start_opt
{ $$ = $1.comp;
- if ($2) $$ = fill_comp (state, DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
+ if ($2) $$ = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2); }
| conversion_op_name abstract_declarator_fn
{ if ($2.last)
{
}
/* If we have an arglist, build a function type. */
if ($2.fn.comp)
- $$ = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
+ $$ = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1.comp, $2.fn.comp);
else
$$ = $1.comp;
- if ($2.start) $$ = fill_comp (state, DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
+ if ($2.start) $$ = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$, $2.start);
}
;
demangler_special
: DEMANGLER_SPECIAL start
- { $$ = fill_comp (state, (enum demangle_component_type) $1, $2, NULL); }
+ { $$ = state->fill_comp ((enum demangle_component_type) $1, $2, NULL); }
| CONSTRUCTION_VTABLE start CONSTRUCTION_IN start
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, $2, $4); }
;
oper : OPERATOR NEW
{
/* Match the whitespacing of cplus_demangle_operators.
It would abort on unrecognized string otherwise. */
- $$ = make_operator (state, "new", 3);
+ $$ = state->make_operator ("new", 3);
}
| OPERATOR DELETE
{
/* Match the whitespacing of cplus_demangle_operators.
It would abort on unrecognized string otherwise. */
- $$ = make_operator (state, "delete ", 1);
+ $$ = state->make_operator ("delete ", 1);
}
| OPERATOR NEW '[' ']'
{
/* Match the whitespacing of cplus_demangle_operators.
It would abort on unrecognized string otherwise. */
- $$ = make_operator (state, "new[]", 3);
+ $$ = state->make_operator ("new[]", 3);
}
| OPERATOR DELETE '[' ']'
{
/* Match the whitespacing of cplus_demangle_operators.
It would abort on unrecognized string otherwise. */
- $$ = make_operator (state, "delete[] ", 1);
+ $$ = state->make_operator ("delete[] ", 1);
}
| OPERATOR '+'
- { $$ = make_operator (state, "+", 2); }
+ { $$ = state->make_operator ("+", 2); }
| OPERATOR '-'
- { $$ = make_operator (state, "-", 2); }
+ { $$ = state->make_operator ("-", 2); }
| OPERATOR '*'
- { $$ = make_operator (state, "*", 2); }
+ { $$ = state->make_operator ("*", 2); }
| OPERATOR '/'
- { $$ = make_operator (state, "/", 2); }
+ { $$ = state->make_operator ("/", 2); }
| OPERATOR '%'
- { $$ = make_operator (state, "%", 2); }
+ { $$ = state->make_operator ("%", 2); }
| OPERATOR '^'
- { $$ = make_operator (state, "^", 2); }
+ { $$ = state->make_operator ("^", 2); }
| OPERATOR '&'
- { $$ = make_operator (state, "&", 2); }
+ { $$ = state->make_operator ("&", 2); }
| OPERATOR '|'
- { $$ = make_operator (state, "|", 2); }
+ { $$ = state->make_operator ("|", 2); }
| OPERATOR '~'
- { $$ = make_operator (state, "~", 1); }
+ { $$ = state->make_operator ("~", 1); }
| OPERATOR '!'
- { $$ = make_operator (state, "!", 1); }
+ { $$ = state->make_operator ("!", 1); }
| OPERATOR '='
- { $$ = make_operator (state, "=", 2); }
+ { $$ = state->make_operator ("=", 2); }
| OPERATOR '<'
- { $$ = make_operator (state, "<", 2); }
+ { $$ = state->make_operator ("<", 2); }
| OPERATOR '>'
- { $$ = make_operator (state, ">", 2); }
+ { $$ = state->make_operator (">", 2); }
| OPERATOR ASSIGN_MODIFY
- { $$ = make_operator (state, $2, 2); }
+ { $$ = state->make_operator ($2, 2); }
| OPERATOR LSH
- { $$ = make_operator (state, "<<", 2); }
+ { $$ = state->make_operator ("<<", 2); }
| OPERATOR RSH
- { $$ = make_operator (state, ">>", 2); }
+ { $$ = state->make_operator (">>", 2); }
| OPERATOR EQUAL
- { $$ = make_operator (state, "==", 2); }
+ { $$ = state->make_operator ("==", 2); }
| OPERATOR NOTEQUAL
- { $$ = make_operator (state, "!=", 2); }
+ { $$ = state->make_operator ("!=", 2); }
| OPERATOR LEQ
- { $$ = make_operator (state, "<=", 2); }
+ { $$ = state->make_operator ("<=", 2); }
| OPERATOR GEQ
- { $$ = make_operator (state, ">=", 2); }
+ { $$ = state->make_operator (">=", 2); }
| OPERATOR ANDAND
- { $$ = make_operator (state, "&&", 2); }
+ { $$ = state->make_operator ("&&", 2); }
| OPERATOR OROR
- { $$ = make_operator (state, "||", 2); }
+ { $$ = state->make_operator ("||", 2); }
| OPERATOR INCREMENT
- { $$ = make_operator (state, "++", 1); }
+ { $$ = state->make_operator ("++", 1); }
| OPERATOR DECREMENT
- { $$ = make_operator (state, "--", 1); }
+ { $$ = state->make_operator ("--", 1); }
| OPERATOR ','
- { $$ = make_operator (state, ",", 2); }
+ { $$ = state->make_operator (",", 2); }
| OPERATOR ARROW '*'
- { $$ = make_operator (state, "->*", 2); }
+ { $$ = state->make_operator ("->*", 2); }
| OPERATOR ARROW
- { $$ = make_operator (state, "->", 2); }
+ { $$ = state->make_operator ("->", 2); }
| OPERATOR '(' ')'
- { $$ = make_operator (state, "()", 2); }
+ { $$ = state->make_operator ("()", 2); }
| OPERATOR '[' ']'
- { $$ = make_operator (state, "[]", 2); }
+ { $$ = state->make_operator ("[]", 2); }
;
/* Conversion operators. We don't try to handle some of
since it's not clear that it's parseable. */
conversion_op
: OPERATOR typespec_2
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_CONVERSION, $2, NULL); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_CONVERSION, $2, NULL); }
;
conversion_op_name
/* This accepts certain invalid placements of '~'. */
unqualified_name: oper
| oper '<' template_params '>'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
| '~' NAME
- { $$ = make_dtor (state, gnu_v3_complete_object_dtor, $2); }
+ { $$ = state->make_dtor (gnu_v3_complete_object_dtor, $2); }
;
/* This rule is used in name and nested_name, and expanded inline there
;
nested_name : NAME COLONCOLON
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_QUAL_NAME, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_QUAL_NAME, $1, NULL);
$$.last = $$.comp;
}
| nested_name NAME COLONCOLON
{ $$.comp = $1.comp;
- d_right ($1.last) = fill_comp (state, DEMANGLE_COMPONENT_QUAL_NAME, $2, NULL);
+ d_right ($1.last) = state->fill_comp (DEMANGLE_COMPONENT_QUAL_NAME, $2, NULL);
$$.last = d_right ($1.last);
}
| templ COLONCOLON
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_QUAL_NAME, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_QUAL_NAME, $1, NULL);
$$.last = $$.comp;
}
| nested_name templ COLONCOLON
{ $$.comp = $1.comp;
- d_right ($1.last) = fill_comp (state, DEMANGLE_COMPONENT_QUAL_NAME, $2, NULL);
+ d_right ($1.last) = state->fill_comp (DEMANGLE_COMPONENT_QUAL_NAME, $2, NULL);
$$.last = d_right ($1.last);
}
;
/* DEMANGLE_COMPONENT_TEMPLATE */
/* DEMANGLE_COMPONENT_TEMPLATE_ARGLIST */
templ : NAME '<' template_params '>'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_TEMPLATE, $1, $3.comp); }
;
template_params : template_arg
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $1, NULL);
$$.last = &d_right ($$.comp); }
| template_params ',' template_arg
{ $$.comp = $1.comp;
- *$1.last = fill_comp (state, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
+ *$1.last = state->fill_comp (DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, $3, NULL);
$$.last = &d_right (*$1.last);
}
;
*$2.last = $1;
}
| '&' start
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY, make_operator (state, "&", 1), $2); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY, state->make_operator ("&", 1), $2); }
| '&' '(' start ')'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY, make_operator (state, "&", 1), $3); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY, state->make_operator ("&", 1), $3); }
| exp
;
function_args : typespec_2
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_ARGLIST, $1, NULL);
$$.last = &d_right ($$.comp);
}
| typespec_2 abstract_declarator
{ *$2.last = $1;
- $$.comp = fill_comp (state, DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
+ $$.comp = state->fill_comp (DEMANGLE_COMPONENT_ARGLIST, $2.comp, NULL);
$$.last = &d_right ($$.comp);
}
| function_args ',' typespec_2
- { *$1.last = fill_comp (state, DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
+ { *$1.last = state->fill_comp (DEMANGLE_COMPONENT_ARGLIST, $3, NULL);
$$.comp = $1.comp;
$$.last = &d_right (*$1.last);
}
| function_args ',' typespec_2 abstract_declarator
{ *$4.last = $3;
- *$1.last = fill_comp (state, DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
+ *$1.last = state->fill_comp (DEMANGLE_COMPONENT_ARGLIST, $4.comp, NULL);
$$.comp = $1.comp;
$$.last = &d_right (*$1.last);
}
| function_args ',' ELLIPSIS
{ *$1.last
- = fill_comp (state, DEMANGLE_COMPONENT_ARGLIST,
- make_builtin_type (state, "..."),
+ = state->fill_comp (DEMANGLE_COMPONENT_ARGLIST,
+ state->make_builtin_type ("..."),
NULL);
$$.comp = $1.comp;
$$.last = &d_right (*$1.last);
;
function_arglist: '(' function_args ')' qualifiers_opt %prec NAME
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, $2.comp);
$$.last = &d_left ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $4, 1); }
+ $$.comp = state->d_qualify ($$.comp, $4, 1); }
| '(' VOID ')' qualifiers_opt
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
$$.last = &d_left ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $4, 1); }
+ $$.comp = state->d_qualify ($$.comp, $4, 1); }
| '(' ')' qualifiers_opt
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_FUNCTION_TYPE, NULL, NULL);
$$.last = &d_left ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $3, 1); }
+ $$.comp = state->d_qualify ($$.comp, $3, 1); }
;
/* Should do something about DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL */
;
builtin_type : int_seq
- { $$ = d_int_type (state, $1); }
+ { $$ = state->d_int_type ($1); }
| FLOAT_KEYWORD
- { $$ = make_builtin_type (state, "float"); }
+ { $$ = state->make_builtin_type ("float"); }
| DOUBLE_KEYWORD
- { $$ = make_builtin_type (state, "double"); }
+ { $$ = state->make_builtin_type ("double"); }
| LONG DOUBLE_KEYWORD
- { $$ = make_builtin_type (state, "long double"); }
+ { $$ = state->make_builtin_type ("long double"); }
| BOOL
- { $$ = make_builtin_type (state, "bool"); }
+ { $$ = state->make_builtin_type ("bool"); }
| WCHAR_T
- { $$ = make_builtin_type (state, "wchar_t"); }
+ { $$ = state->make_builtin_type ("wchar_t"); }
| VOID
- { $$ = make_builtin_type (state, "void"); }
+ { $$ = state->make_builtin_type ("void"); }
;
ptr_operator : '*' qualifiers_opt
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_POINTER, NULL, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_POINTER, NULL, NULL);
$$.last = &d_left ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $2, 0); }
+ $$.comp = state->d_qualify ($$.comp, $2, 0); }
/* g++ seems to allow qualifiers after the reference? */
| '&'
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_REFERENCE, NULL, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_REFERENCE, NULL, NULL);
$$.last = &d_left ($$.comp); }
| ANDAND
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_RVALUE_REFERENCE, NULL, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_RVALUE_REFERENCE, NULL, NULL);
$$.last = &d_left ($$.comp); }
| nested_name '*' qualifiers_opt
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_PTRMEM_TYPE, $1.comp, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_PTRMEM_TYPE, $1.comp, NULL);
/* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
*$1.last = *d_left ($1.last);
$$.last = &d_right ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $3, 0); }
+ $$.comp = state->d_qualify ($$.comp, $3, 0); }
| COLONCOLON nested_name '*' qualifiers_opt
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_PTRMEM_TYPE, $2.comp, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_PTRMEM_TYPE, $2.comp, NULL);
/* Convert the innermost DEMANGLE_COMPONENT_QUAL_NAME to a DEMANGLE_COMPONENT_NAME. */
*$2.last = *d_left ($2.last);
$$.last = &d_right ($$.comp);
- $$.comp = d_qualify (state, $$.comp, $4, 0); }
+ $$.comp = state->d_qualify ($$.comp, $4, 0); }
;
array_indicator : '[' ']'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_ARRAY_TYPE, NULL, NULL); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_ARRAY_TYPE, NULL, NULL); }
| '[' INT ']'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_ARRAY_TYPE, $2, NULL); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_ARRAY_TYPE, $2, NULL); }
;
/* Details of this approach inspired by the G++ < 3.4 parser. */
*/
typespec_2 : builtin_type qualifiers
- { $$ = d_qualify (state, $1, $2, 0); }
+ { $$ = state->d_qualify ($1, $2, 0); }
| builtin_type
| qualifiers builtin_type qualifiers
- { $$ = d_qualify (state, $2, $1 | $3, 0); }
+ { $$ = state->d_qualify ($2, $1 | $3, 0); }
| qualifiers builtin_type
- { $$ = d_qualify (state, $2, $1, 0); }
+ { $$ = state->d_qualify ($2, $1, 0); }
| name qualifiers
- { $$ = d_qualify (state, $1, $2, 0); }
+ { $$ = state->d_qualify ($1, $2, 0); }
| name
| qualifiers name qualifiers
- { $$ = d_qualify (state, $2, $1 | $3, 0); }
+ { $$ = state->d_qualify ($2, $1 | $3, 0); }
| qualifiers name
- { $$ = d_qualify (state, $2, $1, 0); }
+ { $$ = state->d_qualify ($2, $1, 0); }
| COLONCOLON name qualifiers
- { $$ = d_qualify (state, $2, $3, 0); }
+ { $$ = state->d_qualify ($2, $3, 0); }
| COLONCOLON name
{ $$ = $2; }
| qualifiers COLONCOLON name qualifiers
- { $$ = d_qualify (state, $3, $1 | $4, 0); }
+ { $$ = state->d_qualify ($3, $1 | $4, 0); }
| qualifiers COLONCOLON name
- { $$ = d_qualify (state, $3, $1, 0); }
+ { $$ = state->d_qualify ($3, $1, 0); }
;
abstract_declarator
$$.last = &d_right ($2);
}
| colon_ext_name
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, NULL);
$$.last = &d_right ($$.comp);
}
;
$$.last = $1.last;
*$2.last = $1.comp; }
| colon_ext_name
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, NULL);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, NULL);
$$.last = &d_right ($$.comp);
}
| direct_declarator_1
members will not be mangled. If they are hopefully
they'll end up to the right of the ::. */
| colon_ext_name function_arglist COLONCOLON start
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
$$.last = $2.last;
- $$.comp = fill_comp (state, DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
+ $$.comp = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
}
| direct_declarator_1 function_arglist COLONCOLON start
{ $$.comp = $1.comp;
*$1.last = $2.comp;
$$.last = $2.last;
- $$.comp = fill_comp (state, DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
+ $$.comp = state->fill_comp (DEMANGLE_COMPONENT_LOCAL_NAME, $$.comp, $4);
}
;
$$.last = &d_right ($2);
}
| colon_ext_name function_arglist
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2.comp);
$$.last = $2.last;
}
| colon_ext_name array_indicator
- { $$.comp = fill_comp (state, DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
+ { $$.comp = state->fill_comp (DEMANGLE_COMPONENT_TYPED_NAME, $1, $2);
$$.last = &d_right ($2);
}
;
;
exp1 : exp '>' exp
- { $$ = d_binary (state, ">", $1, $3); }
+ { $$ = state->d_binary (">", $1, $3); }
;
/* References. Not allowed everywhere in template parameters, only
at the top level, but treat them as expressions in case they are wrapped
in parentheses. */
exp1 : '&' start
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY, make_operator (state, "&", 1), $2); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY, state->make_operator ("&", 1), $2); }
| '&' '(' start ')'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY, make_operator (state, "&", 1), $3); }
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY, state->make_operator ("&", 1), $3); }
;
/* Expressions, not including the comma operator. */
exp : '-' exp %prec UNARY
- { $$ = d_unary (state, "-", $2); }
+ { $$ = state->d_unary ("-", $2); }
;
exp : '!' exp %prec UNARY
- { $$ = d_unary (state, "!", $2); }
+ { $$ = state->d_unary ("!", $2); }
;
exp : '~' exp %prec UNARY
- { $$ = d_unary (state, "~", $2); }
+ { $$ = state->d_unary ("~", $2); }
;
/* Casts. First your normal C-style cast. If exp is a LITERAL, just change
d_left ($4) = $2;
}
else
- $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY,
- fill_comp (state, DEMANGLE_COMPONENT_CAST, $2, NULL),
+ $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY,
+ state->fill_comp (DEMANGLE_COMPONENT_CAST, $2, NULL),
$4);
}
;
/* Mangling does not differentiate between these, so we don't need to
either. */
exp : STATIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY,
- fill_comp (state, DEMANGLE_COMPONENT_CAST, $3, NULL),
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY,
+ state->fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
$6);
}
;
exp : DYNAMIC_CAST '<' type '>' '(' exp1 ')' %prec UNARY
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY,
- fill_comp (state, DEMANGLE_COMPONENT_CAST, $3, NULL),
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY,
+ state->fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
$6);
}
;
exp : REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_UNARY,
- fill_comp (state, DEMANGLE_COMPONENT_CAST, $3, NULL),
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_UNARY,
+ state->fill_comp (DEMANGLE_COMPONENT_CAST, $3, NULL),
$6);
}
;
/* Binary operators in order of decreasing precedence. */
exp : exp '*' exp
- { $$ = d_binary (state, "*", $1, $3); }
+ { $$ = state->d_binary ("*", $1, $3); }
;
exp : exp '/' exp
- { $$ = d_binary (state, "/", $1, $3); }
+ { $$ = state->d_binary ("/", $1, $3); }
;
exp : exp '%' exp
- { $$ = d_binary (state, "%", $1, $3); }
+ { $$ = state->d_binary ("%", $1, $3); }
;
exp : exp '+' exp
- { $$ = d_binary (state, "+", $1, $3); }
+ { $$ = state->d_binary ("+", $1, $3); }
;
exp : exp '-' exp
- { $$ = d_binary (state, "-", $1, $3); }
+ { $$ = state->d_binary ("-", $1, $3); }
;
exp : exp LSH exp
- { $$ = d_binary (state, "<<", $1, $3); }
+ { $$ = state->d_binary ("<<", $1, $3); }
;
exp : exp RSH exp
- { $$ = d_binary (state, ">>", $1, $3); }
+ { $$ = state->d_binary (">>", $1, $3); }
;
exp : exp EQUAL exp
- { $$ = d_binary (state, "==", $1, $3); }
+ { $$ = state->d_binary ("==", $1, $3); }
;
exp : exp NOTEQUAL exp
- { $$ = d_binary (state, "!=", $1, $3); }
+ { $$ = state->d_binary ("!=", $1, $3); }
;
exp : exp LEQ exp
- { $$ = d_binary (state, "<=", $1, $3); }
+ { $$ = state->d_binary ("<=", $1, $3); }
;
exp : exp GEQ exp
- { $$ = d_binary (state, ">=", $1, $3); }
+ { $$ = state->d_binary (">=", $1, $3); }
;
exp : exp '<' exp
- { $$ = d_binary (state, "<", $1, $3); }
+ { $$ = state->d_binary ("<", $1, $3); }
;
exp : exp '&' exp
- { $$ = d_binary (state, "&", $1, $3); }
+ { $$ = state->d_binary ("&", $1, $3); }
;
exp : exp '^' exp
- { $$ = d_binary (state, "^", $1, $3); }
+ { $$ = state->d_binary ("^", $1, $3); }
;
exp : exp '|' exp
- { $$ = d_binary (state, "|", $1, $3); }
+ { $$ = state->d_binary ("|", $1, $3); }
;
exp : exp ANDAND exp
- { $$ = d_binary (state, "&&", $1, $3); }
+ { $$ = state->d_binary ("&&", $1, $3); }
;
exp : exp OROR exp
- { $$ = d_binary (state, "||", $1, $3); }
+ { $$ = state->d_binary ("||", $1, $3); }
;
/* Not 100% sure these are necessary, but they're harmless. */
exp : exp ARROW NAME
- { $$ = d_binary (state, "->", $1, $3); }
+ { $$ = state->d_binary ("->", $1, $3); }
;
exp : exp '.' NAME
- { $$ = d_binary (state, ".", $1, $3); }
+ { $$ = state->d_binary (".", $1, $3); }
;
exp : exp '?' exp ':' exp %prec '?'
- { $$ = fill_comp (state, DEMANGLE_COMPONENT_TRINARY, make_operator (state, "?", 3),
- fill_comp (state, DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
- fill_comp (state, DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
+ { $$ = state->fill_comp (DEMANGLE_COMPONENT_TRINARY, state->make_operator ("?", 3),
+ state->fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG1, $1,
+ state->fill_comp (DEMANGLE_COMPONENT_TRINARY_ARG2, $3, $5)));
}
;
{
/* Match the whitespacing of cplus_demangle_operators.
It would abort on unrecognized string otherwise. */
- $$ = d_unary (state, "sizeof ", $3);
+ $$ = state->d_unary ("sizeof ", $3);
}
;
/* C++. */
exp : TRUEKEYWORD
{ struct demangle_component *i;
- i = make_name (state, "1", 1);
- $$ = fill_comp (state, DEMANGLE_COMPONENT_LITERAL,
- make_builtin_type (state, "bool"),
+ i = state->make_name ("1", 1);
+ $$ = state->fill_comp (DEMANGLE_COMPONENT_LITERAL,
+ state->make_builtin_type ( "bool"),
i);
}
;
exp : FALSEKEYWORD
{ struct demangle_component *i;
- i = make_name (state, "0", 1);
- $$ = fill_comp (state, DEMANGLE_COMPONENT_LITERAL,
- make_builtin_type (state, "bool"),
+ i = state->make_name ("0", 1);
+ $$ = state->fill_comp (DEMANGLE_COMPONENT_LITERAL,
+ state->make_builtin_type ("bool"),
i);
}
;
may already be qualified; duplicate qualifiers are not created. */
struct demangle_component *
-d_qualify (cpname_state *state, struct demangle_component *lhs, int qualifiers,
- int is_method)
+cpname_state::d_qualify (struct demangle_component *lhs, int qualifiers,
+ int is_method)
{
struct demangle_component **inner_p;
enum demangle_component_type type;
#define HANDLE_QUAL(TYPE, MTYPE, QUAL) \
if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \
{ \
- *inner_p = fill_comp (state, is_method ? MTYPE : TYPE, \
- *inner_p, NULL); \
+ *inner_p = fill_comp (is_method ? MTYPE : TYPE, \
+ *inner_p, NULL); \
inner_p = &d_left (*inner_p); \
type = (*inner_p)->type; \
} \
/* Return a builtin type corresponding to FLAGS. */
-static struct demangle_component *
-d_int_type (cpname_state *state, int flags)
+struct demangle_component *
+cpname_state::d_int_type (int flags)
{
const char *name;
return NULL;
}
- return make_builtin_type (state, name);
+ return make_builtin_type (name);
}
/* Wrapper to create a unary operation. */
-static struct demangle_component *
-d_unary (cpname_state *state, const char *name, struct demangle_component *lhs)
+struct demangle_component *
+cpname_state::d_unary (const char *name, struct demangle_component *lhs)
{
- return fill_comp (state, DEMANGLE_COMPONENT_UNARY, make_operator (state, name, 1), lhs);
+ return fill_comp (DEMANGLE_COMPONENT_UNARY, make_operator (name, 1), lhs);
}
/* Wrapper to create a binary operation. */
-static struct demangle_component *
-d_binary (cpname_state *state, const char *name, struct demangle_component *lhs,
- struct demangle_component *rhs)
+struct demangle_component *
+cpname_state::d_binary (const char *name, struct demangle_component *lhs,
+ struct demangle_component *rhs)
{
- return fill_comp (state, DEMANGLE_COMPONENT_BINARY, make_operator (state, name, 2),
- fill_comp (state, DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
+ return fill_comp (DEMANGLE_COMPONENT_BINARY, make_operator (name, 2),
+ fill_comp (DEMANGLE_COMPONENT_BINARY_ARGS, lhs, rhs));
}
/* Find the end of a symbol name starting at LEXPTR. */
The number starts at P and contains LEN characters. Store the result in
YYLVAL. */
-static int
-parse_number (cpname_state *state, const char *p, int len, int parsed_float,
- YYSTYPE *lvalp)
+int
+cpname_state::parse_number (const char *p, int len, int parsed_float,
+ YYSTYPE *lvalp)
{
int unsigned_p = 0;
if (c == 'f')
{
len--;
- type = make_builtin_type (state, "float");
+ type = make_builtin_type ("float");
}
else if (c == 'l')
{
len--;
- type = make_builtin_type (state, "long double");
+ type = make_builtin_type ("long double");
}
else if (ISDIGIT (c) || c == '.')
- type = make_builtin_type (state, "double");
+ type = make_builtin_type ("double");
else
return ERROR;
- name = make_name (state, p, len);
- lvalp->comp = fill_comp (state, literal_type, type, name);
+ name = make_name (p, len);
+ lvalp->comp = fill_comp (literal_type, type, name);
return FLOAT;
}
if (long_p == 0)
{
- unsigned_type = make_builtin_type (state, "unsigned int");
- signed_type = make_builtin_type (state, "int");
+ unsigned_type = make_builtin_type ("unsigned int");
+ signed_type = make_builtin_type ("int");
}
else if (long_p == 1)
{
- unsigned_type = make_builtin_type (state, "unsigned long");
- signed_type = make_builtin_type (state, "long");
+ unsigned_type = make_builtin_type ("unsigned long");
+ signed_type = make_builtin_type ("long");
}
else
{
- unsigned_type = make_builtin_type (state, "unsigned long long");
- signed_type = make_builtin_type (state, "long long");
+ unsigned_type = make_builtin_type ("unsigned long long");
+ signed_type = make_builtin_type ("long long");
}
if (unsigned_p)
else
type = signed_type;
- name = make_name (state, p, len);
- lvalp->comp = fill_comp (state, literal_type, type, name);
+ name = make_name (p, len);
+ lvalp->comp = fill_comp (literal_type, type, name);
return INT;
}
presumably the same one that appears in manglings - the decimal
representation. But if that isn't in our input then we have to
allocate memory for it somewhere. */
- lvalp->comp = fill_comp (state, DEMANGLE_COMPONENT_LITERAL,
- make_builtin_type (state, "char"),
- make_name (state, tokstart, state->lexptr - tokstart));
+ lvalp->comp
+ = state->fill_comp (DEMANGLE_COMPONENT_LITERAL,
+ state->make_builtin_type ("char"),
+ state->make_name (tokstart,
+ state->lexptr - tokstart));
return INT;
if (strncmp (tokstart, "(anonymous namespace)", 21) == 0)
{
state->lexptr += 21;
- lvalp->comp = make_name (state, "(anonymous namespace)",
- sizeof "(anonymous namespace)" - 1);
+ lvalp->comp = state->make_name ("(anonymous namespace)",
+ sizeof "(anonymous namespace)" - 1);
return NAME;
}
/* FALL THROUGH */
else if (! ISALNUM (*p))
break;
}
- toktype = parse_number (state, tokstart, p - tokstart, got_dot|got_e,
- lvalp);
+ toktype = state->parse_number (tokstart, p - tokstart, got_dot|got_e,
+ lvalp);
if (toktype == ERROR)
{
char *err_copy = (char *) alloca (p - tokstart + 1);
lvalp->lval = DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS;
/* Find the end of the symbol. */
p = symbol_end (state->lexptr);
- lvalp->comp = make_name (state, state->lexptr, p - state->lexptr);
+ lvalp->comp = state->make_name (state->lexptr, p - state->lexptr);
state->lexptr = p;
return DEMANGLER_SPECIAL;
}
lvalp->lval = DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS;
/* Find the end of the symbol. */
p = symbol_end (state->lexptr);
- lvalp->comp = make_name (state, state->lexptr, p - state->lexptr);
+ lvalp->comp = state->make_name (state->lexptr, p - state->lexptr);
state->lexptr = p;
return DEMANGLER_SPECIAL;
}
break;
}
- lvalp->comp = make_name (state, tokstart, namelen);
+ lvalp->comp = state->make_name (tokstart, namelen);
return NAME;
}
projects / binutils-gdb.git / commitdiff