From patchwork Fri Jun 1 17:51:52 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 27600 Received: (qmail 30562 invoked by alias); 1 Jun 2018 17:52:02 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 30538 invoked by uid 89); 1 Jun 2018 17:52:02 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, T_FILL_THIS_FORM_SHORT autolearn=ham version=3.3.2 spammy=Binary, mangling X-HELO: gateway21.websitewelcome.com Received: from gateway21.websitewelcome.com (HELO gateway21.websitewelcome.com) (192.185.45.155) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 01 Jun 2018 17:51:57 +0000 Received: from cm14.websitewelcome.com (cm14.websitewelcome.com [100.42.49.7]) by gateway21.websitewelcome.com (Postfix) with ESMTP id 9B908404C0636 for ; Fri, 1 Jun 2018 12:51:55 -0500 (CDT) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id OoDTf8CptkBj6OoDTfccK3; Fri, 01 Jun 2018 12:51:55 -0500 X-Authority-Reason: nr=8 Received: from 75-166-42-107.hlrn.qwest.net ([75.166.42.107]:36370 helo=pokyo.Home) by box5379.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.91) (envelope-from ) id 1fOoDT-000zQB-9D; Fri, 01 Jun 2018 12:51:55 -0500 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [RFA] Change functions in cp-name-parser.y into methods Date: Fri, 1 Jun 2018 11:51:52 -0600 Message-Id: <20180601175152.24165-1-tom@tromey.com> X-BWhitelist: no X-Source-L: No X-Exim-ID: 1fOoDT-000zQB-9D X-Source-Sender: 75-166-42-107.hlrn.qwest.net (pokyo.Home) [75.166.42.107]:36370 X-Source-Auth: tom+tromey.com X-Email-Count: 1 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTM3OS5ibHVlaG9zdC5jb20= X-Local-Domain: yes Pedro pointed out in an earlier patch that it would be possible to make some helper functions in cp-name-parser.y into methods on cpname_state, cleaning up the code a bit. This patch implements this idea. Doing this required moving the %union earlier in the .y file, so the patch is somewhat bigger than you might expect. Tested by building with both bison and byacc, and then running the gdb.cp tests. ChangeLog 2018-06-01 Tom Tromey * cp-name-parser.y (cpname_state): Add method declarations. (HANDLE_QUAL): Update. (cpname_state::d_grab, cpname_state::fill_comp) (cpname_state::make_operator, cpname_state::make_dtor) (cpname_state::make_builtin_type, cpname_state::make_name) (cpname_state::d_qualify, cpname_state::d_int_type) (cpname_state::d_unary, cpname_state::d_binary): Now methods. (%union): Move earlier. --- gdb/ChangeLog | 11 ++ gdb/cp-name-parser.y | 526 ++++++++++++++++++++++++++------------------------- 2 files changed, 284 insertions(+), 253 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index f1eed4e7299..77b5949c3fd 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2018-06-01 Tom Tromey + + * cp-name-parser.y (cpname_state): Add method declarations. + (HANDLE_QUAL): Update. + (cpname_state::d_grab, cpname_state::fill_comp) + (cpname_state::make_operator, cpname_state::make_dtor) + (cpname_state::make_builtin_type, cpname_state::make_name) + (cpname_state::d_qualify, cpname_state::d_int_type) + (cpname_state::d_unary, cpname_state::d_binary): Now methods. + (%union): Move earlier. + 2018-06-01 Tom Tromey * cp-name-parser.y (backslashable, represented): Now const. diff --git a/gdb/cp-name-parser.y b/gdb/cp-name-parser.y index b8a3faa3df8..72ffc8aa7dc 100644 --- a/gdb/cp-name-parser.y +++ b/gdb/cp-name-parser.y @@ -60,12 +60,36 @@ struct demangle_info { 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; @@ -75,45 +99,63 @@ struct cpname_state 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 @@ -138,12 +180,12 @@ static struct demangle_component *d_binary (cpname_state *state, const char *, /* 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); @@ -152,10 +194,10 @@ fill_comp (cpname_state *state, 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); @@ -164,11 +206,11 @@ make_operator (cpname_state *state, const char *name, int 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); @@ -177,10 +219,10 @@ make_dtor (cpname_state *state, enum gnu_v3_dtor_kinds kind, 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); @@ -189,10 +231,10 @@ make_builtin_type (cpname_state *state, const char *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); @@ -204,29 +246,6 @@ make_name (cpname_state *state, const char *name, int 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 *); %} @@ -357,20 +376,19 @@ function 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) { @@ -382,102 +400,102 @@ function } /* 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 @@ -485,7 +503,7 @@ oper : OPERATOR NEW 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 @@ -513,9 +531,9 @@ 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 @@ -556,21 +574,21 @@ ext_only_name : nested_name unqualified_name ; 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); } ; @@ -578,15 +596,15 @@ nested_name : NAME COLONCOLON /* 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); } ; @@ -601,36 +619,36 @@ template_arg : typespec_2 *$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); @@ -638,17 +656,17 @@ function_args : typespec_2 ; 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 */ @@ -693,50 +711,50 @@ int_seq : int_part ; 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. */ @@ -750,29 +768,29 @@ typespec : builtin_type */ 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 @@ -889,7 +907,7 @@ direct_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); } ; @@ -905,7 +923,7 @@ declarator_1 : ptr_operator declarator_1 $$.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 @@ -917,15 +935,15 @@ declarator_1 : ptr_operator 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); } ; @@ -945,11 +963,11 @@ direct_declarator_1 $$.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); } ; @@ -964,29 +982,29 @@ exp1 : exp ; 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 @@ -1000,8 +1018,8 @@ exp : '(' type ')' exp %prec UNARY 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); } ; @@ -1009,22 +1027,22 @@ exp : '(' type ')' exp %prec UNARY /* 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); } ; @@ -1042,86 +1060,86 @@ exp : REINTERPRET_CAST '<' type '>' '(' exp1 ')' %prec UNARY /* 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))); } ; @@ -1136,25 +1154,25 @@ exp : SIZEOF '(' type ')' %prec UNARY { /* 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); } ; @@ -1169,8 +1187,8 @@ exp : FALSEKEYWORD 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; @@ -1180,8 +1198,8 @@ d_qualify (cpname_state *state, struct demangle_component *lhs, int qualifiers, #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; \ } \ @@ -1204,8 +1222,8 @@ d_qualify (cpname_state *state, struct demangle_component *lhs, int qualifiers, /* 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; @@ -1252,25 +1270,25 @@ d_int_type (cpname_state *state, int flags) 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. */ @@ -1290,9 +1308,9 @@ symbol_end (const char *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; @@ -1329,20 +1347,20 @@ parse_number (cpname_state *state, const char *p, int len, int parsed_float, 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; } @@ -1371,18 +1389,18 @@ parse_number (cpname_state *state, const char *p, int len, int parsed_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) @@ -1390,8 +1408,8 @@ parse_number (cpname_state *state, const char *p, int len, int parsed_float, 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; } @@ -1565,9 +1583,11 @@ yylex (YYSTYPE *lvalp, cpname_state *state) 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; @@ -1575,8 +1595,8 @@ yylex (YYSTYPE *lvalp, cpname_state *state) 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 */ @@ -1674,8 +1694,8 @@ yylex (YYSTYPE *lvalp, cpname_state *state) 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); @@ -1831,7 +1851,7 @@ yylex (YYSTYPE *lvalp, cpname_state *state) 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; } @@ -1842,7 +1862,7 @@ yylex (YYSTYPE *lvalp, cpname_state *state) 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; } @@ -1900,7 +1920,7 @@ yylex (YYSTYPE *lvalp, cpname_state *state) break; } - lvalp->comp = make_name (state, tokstart, namelen); + lvalp->comp = state->make_name (tokstart, namelen); return NAME; }