From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id 6U6zKSzDvmrsWCUAWB0awg (envelope-from ) for ; Thu, 01 Oct 2026 16:31:40 -0400 Received: by simark.ca (Postfix, from userid 112) id A78D61E04F; Thu, 01 Oct 2026 16:31:40 -0400 (EDT) X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-25) on simark.ca X-Spam-Level: X-Spam-Status: No, score=-5.3 required=5.0 tests=ARC_SIGNED,ARC_VALID,BAYES_00, MAILING_LIST_MULTI,RCVD_IN_DNSWL_MED autolearn=ham autolearn_force=no version=4.0.1 Received: from vm01.sourceware.org (vm01.sourceware.org [IPv6:2620:52:6:3111::32]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id BD1961E047 for ; Thu, 01 Oct 2026 16:31:38 -0400 (EDT) Received: from vm01.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 866064BB58E8 for ; Thu, 1 Oct 2026 20:31:37 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 866064BB58E8 Received: from simark.ca (simark.ca [158.69.221.121]) by sourceware.org (Postfix) with ESMTPS id 71B6E4BB24E0 for ; Thu, 1 Oct 2026 20:31:13 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 71B6E4BB24E0 Authentication-Results: sourceware.org; dmarc=fail (p=none dis=none) header.from=efficios.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=efficios.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 71B6E4BB24E0 Authentication-Results: sourceware.org; arc=none smtp.remote-ip=158.69.221.121 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1790886673; cv=none; b=CgjQ3RucNXeC+JaK89PDYwcRJrdb/4RXmlpugwrept25fJVNoEpVtuxb5OJVQxHfZ2emZqT0kYHEk8LiZAbWCKps1nefEFMkOWG/iC9FkWdenvdIVsHKuT9aH14b2s4wwTr30uHoNGixOVqUdu+IfbX4KUrBpnA3SKXjpKT/QcU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1790886673; c=relaxed/simple; bh=gtx1RXhYCjpVP/OYxatttQXmFsYKNbNPARK5NsaGwnw=; h=From:To:Subject:Date:Message-ID:MIME-Version; b=YhYLD2SUpxPbhR8vQ65enLgR7rKKA+TFK17W6xLbYrF60CfESaCEmKmHWYLWPI422TqHAnwxdLAoXEqIlR49NjU+j6iuSNOrEW0NYTWkM34zIXv4JSC7qKJjJaEVV437i16i5ETgC2qVLj8/4dhAjGv9G5VMLiJJkZTRbmCPf/I= ARC-Authentication-Results: i=1; sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 71B6E4BB24E0 Received: by simark.ca (Postfix) id 8C0BC1E090; Thu, 01 Oct 2026 16:31:12 -0400 (EDT) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [PATCH 4/7] gdb: replace cp-name-parser.c macros with lambdas Date: Thu, 1 Oct 2026 16:30:02 -0400 Message-ID: <20261001203105.1379971-5-simon.marchi@efficios.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20261001203105.1379971-1-simon.marchi@efficios.com> References: <20261001203105.1379971-1-simon.marchi@efficios.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~public-inbox=simark.ca@sourceware.org Replace the HANDLE_QUAL, HANDLE_SPECIAL, HANDLE_TOKEN2 and HANDLE_TOKEN3 macros with lambdas. The lexer macros expanded to a return statement. The lambdas instead return whether they matched, and the call sites return the token: if (match_op_token ("-=")) return ASSIGN_MODIFY; HANDLE_TOKEN2 and HANDLE_TOKEN3 only differed in the number of characters they compared, so they become a single match_op_token lambda comparing the whole string. Change-Id: I1319e2e8bb9650ee253e429912c596df26ccaf6c --- gdb/cp-name-parser.c | 202 +++++++++++++++++++++++++------------------ 1 file changed, 120 insertions(+), 82 deletions(-) diff --git a/gdb/cp-name-parser.c b/gdb/cp-name-parser.c index 6615efd6abb1..80779fbc6062 100644 --- a/gdb/cp-name-parser.c +++ b/gdb/cp-name-parser.c @@ -113,33 +113,34 @@ struct demangle_component * cpname_state::d_qualify (struct demangle_component *lhs, qual_flags qualifiers, int is_method) { - struct demangle_component **inner_p; - enum demangle_component_type type; + demangle_component **inner_p = &lhs; + demangle_component_type type = (*inner_p)->type; + + auto handle_qual = [&] (demangle_component_type qual_type, + demangle_component_type method_qual_type, + qual_flag qual) + { + if ((qualifiers & qual) && type != qual_type && type != method_qual_type) + { + *inner_p = fill_comp (is_method ? method_qual_type : qual_type, + *inner_p, nullptr); + inner_p = &d_left (*inner_p); + type = (*inner_p)->type; + } + else if (type == qual_type || type == method_qual_type) + { + inner_p = &d_left (*inner_p); + type = (*inner_p)->type; + } + }; /* For now the order is CONST (innermost), VOLATILE, RESTRICT. */ - -#define HANDLE_QUAL(TYPE, MTYPE, QUAL) \ - if ((qualifiers & QUAL) && (type != TYPE) && (type != MTYPE)) \ - { \ - *inner_p = fill_comp (is_method ? MTYPE : TYPE, \ - *inner_p, NULL); \ - inner_p = &d_left (*inner_p); \ - type = (*inner_p)->type; \ - } \ - else if (type == TYPE || type == MTYPE) \ - { \ - inner_p = &d_left (*inner_p); \ - type = (*inner_p)->type; \ - } - - inner_p = &lhs; - - type = (*inner_p)->type; - - HANDLE_QUAL (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, QUAL_RESTRICT); - HANDLE_QUAL (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, QUAL_VOLATILE); - HANDLE_QUAL (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, QUAL_CONST); -#undef HANDLE_QUAL + handle_qual (DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, + QUAL_RESTRICT); + handle_qual (DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, + QUAL_VOLATILE); + handle_qual (DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, + QUAL_CONST); return lhs; } @@ -546,30 +547,6 @@ cp_parse_escape (const char **string_ptr) } } -#define HANDLE_SPECIAL(string, comp) \ - if (startswith (tokstart, string)) \ - { \ - state->lexptr = tokstart + sizeof (string) - 1; \ - lvalp->lval = comp; \ - return DEMANGLER_SPECIAL; \ - } - -#define HANDLE_TOKEN2(string, token) \ - if (state->lexptr[1] == string[1]) \ - { \ - state->lexptr += 2; \ - lvalp->opname = string; \ - return token; \ - } - -#define HANDLE_TOKEN3(string, token) \ - if (state->lexptr[1] == string[1] && state->lexptr[2] == string[2]) \ - { \ - state->lexptr += 3; \ - lvalp->opname = string; \ - return token; \ - } - void cpname_yyerror (cp_name_parser::cpname_state *state, const char *msg) { @@ -591,6 +568,30 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, const char *tokstart; char *copy; + /* If the input starts with OP_STR, consume it, use OP_STR as the + token's operator name and return true. Otherwise, return false. */ + auto match_op_token = [&] (const char *op_str) + { + if (!startswith (tokstart, op_str)) + return false; + + state->lexptr = tokstart + strlen (op_str); + lvalp->opname = op_str; + return true; + }; + + /* If the input starts with STR, consume it, use COMP as the token + value and return true. Otherwise, return false. */ + auto match_special = [&] (const char *str, demangle_component_type comp) + { + if (!startswith (tokstart, str)) + return false; + + state->lexptr = tokstart + strlen (str); + lvalp->lval = comp; + return true; + }; + retry: state->prev_lexptr = state->lexptr; tokstart = state->lexptr; @@ -667,9 +668,12 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, goto try_number; case '-': - HANDLE_TOKEN2 ("-=", ASSIGN_MODIFY); - HANDLE_TOKEN2 ("--", DECREMENT); - HANDLE_TOKEN2 ("->", ARROW); + if (match_op_token ("-=")) + return ASSIGN_MODIFY; + if (match_op_token ("--")) + return DECREMENT; + if (match_op_token ("->")) + return ARROW; /* For construction vtables. This is kind of hokey. */ if (startswith (tokstart, "-in-")) @@ -771,59 +775,79 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, } case '+': - HANDLE_TOKEN2 ("+=", ASSIGN_MODIFY); - HANDLE_TOKEN2 ("++", INCREMENT); + if (match_op_token ("+=")) + return ASSIGN_MODIFY; + if (match_op_token ("++")) + return INCREMENT; state->lexptr++; return c; case '*': - HANDLE_TOKEN2 ("*=", ASSIGN_MODIFY); + if (match_op_token ("*=")) + return ASSIGN_MODIFY; state->lexptr++; return c; case '/': - HANDLE_TOKEN2 ("/=", ASSIGN_MODIFY); + if (match_op_token ("/=")) + return ASSIGN_MODIFY; state->lexptr++; return c; case '%': - HANDLE_TOKEN2 ("%=", ASSIGN_MODIFY); + if (match_op_token ("%=")) + return ASSIGN_MODIFY; state->lexptr++; return c; case '|': - HANDLE_TOKEN2 ("|=", ASSIGN_MODIFY); - HANDLE_TOKEN2 ("||", OROR); + if (match_op_token ("|=")) + return ASSIGN_MODIFY; + if (match_op_token ("||")) + return OROR; state->lexptr++; return c; case '&': - HANDLE_TOKEN2 ("&=", ASSIGN_MODIFY); - HANDLE_TOKEN2 ("&&", ANDAND); + if (match_op_token ("&=")) + return ASSIGN_MODIFY; + if (match_op_token ("&&")) + return ANDAND; state->lexptr++; return c; case '^': - HANDLE_TOKEN2 ("^=", ASSIGN_MODIFY); + if (match_op_token ("^=")) + return ASSIGN_MODIFY; state->lexptr++; return c; case '!': - HANDLE_TOKEN2 ("!=", NOTEQUAL); + if (match_op_token ("!=")) + return NOTEQUAL; state->lexptr++; return c; case '<': - HANDLE_TOKEN3 ("<<=", ASSIGN_MODIFY); - HANDLE_TOKEN3 ("<=>", SPACESHIP); - HANDLE_TOKEN2 ("<=", LEQ); - HANDLE_TOKEN2 ("<<", LSH); + if (match_op_token ("<<=")) + return ASSIGN_MODIFY; + if (match_op_token ("<=>")) + return SPACESHIP; + if (match_op_token ("<=")) + return LEQ; + if (match_op_token ("<<")) + return LSH; state->lexptr++; return c; case '>': - HANDLE_TOKEN3 (">>=", ASSIGN_MODIFY); - HANDLE_TOKEN2 (">=", GEQ); - HANDLE_TOKEN2 (">>", RSH); + if (match_op_token (">>=")) + return ASSIGN_MODIFY; + if (match_op_token (">=")) + return GEQ; + if (match_op_token (">>")) + return RSH; state->lexptr++; return c; case '=': - HANDLE_TOKEN2 ("==", EQUAL); + if (match_op_token ("==")) + return EQUAL; state->lexptr++; return c; case ':': - HANDLE_TOKEN2 ("::", COLONCOLON); + if (match_op_token ("::")) + return COLONCOLON; state->lexptr++; return c; @@ -882,13 +906,21 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, return STATIC_CAST; break; case 9: - HANDLE_SPECIAL ("covariant return thunk to ", DEMANGLE_COMPONENT_COVARIANT_THUNK); - HANDLE_SPECIAL ("reference temporary for ", DEMANGLE_COMPONENT_REFTEMP); + if (match_special ("covariant return thunk to ", + DEMANGLE_COMPONENT_COVARIANT_THUNK)) + return DEMANGLER_SPECIAL; + if (match_special ("reference temporary for ", + DEMANGLE_COMPONENT_REFTEMP)) + return DEMANGLER_SPECIAL; break; case 8: - HANDLE_SPECIAL ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO); - HANDLE_SPECIAL ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN); - HANDLE_SPECIAL ("typeinfo name for ", DEMANGLE_COMPONENT_TYPEINFO_NAME); + if (match_special ("typeinfo for ", DEMANGLE_COMPONENT_TYPEINFO)) + return DEMANGLER_SPECIAL; + if (match_special ("typeinfo fn for ", DEMANGLE_COMPONENT_TYPEINFO_FN)) + return DEMANGLER_SPECIAL; + if (match_special ("typeinfo name for ", + DEMANGLE_COMPONENT_TYPEINFO_NAME)) + return DEMANGLER_SPECIAL; if (startswith (tokstart, "operator")) return OPERATOR; if (startswith (tokstart, "restrict")) @@ -901,7 +933,9 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, return VOLATILE_KEYWORD; break; case 7: - HANDLE_SPECIAL ("virtual thunk to ", DEMANGLE_COMPONENT_VIRTUAL_THUNK); + if (match_special ("virtual thunk to ", + DEMANGLE_COMPONENT_VIRTUAL_THUNK)) + return DEMANGLER_SPECIAL; if (startswith (tokstart, "wchar_t")) return WCHAR_T; break; @@ -929,7 +963,8 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, return DEMANGLER_SPECIAL; } - HANDLE_SPECIAL ("vtable for ", DEMANGLE_COMPONENT_VTABLE); + if (match_special ("vtable for ", DEMANGLE_COMPONENT_VTABLE)) + return DEMANGLER_SPECIAL; if (startswith (tokstart, "delete")) return DELETE; if (startswith (tokstart, "struct")) @@ -942,7 +977,8 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, return DOUBLE_KEYWORD; break; case 5: - HANDLE_SPECIAL ("guard variable for ", DEMANGLE_COMPONENT_GUARD); + if (match_special ("guard variable for ", DEMANGLE_COMPONENT_GUARD)) + return DEMANGLER_SPECIAL; if (startswith (tokstart, "false")) return FALSEKEYWORD; if (startswith (tokstart, "class")) @@ -971,8 +1007,10 @@ cpname_yylex (cp_name_parser_YYSTYPE *lvalp, return TRUEKEYWORD; break; case 3: - HANDLE_SPECIAL ("VTT for ", DEMANGLE_COMPONENT_VTT); - HANDLE_SPECIAL ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK); + if (match_special ("VTT for ", DEMANGLE_COMPONENT_VTT)) + return DEMANGLER_SPECIAL; + if (match_special ("non-virtual thunk to ", DEMANGLE_COMPONENT_THUNK)) + return DEMANGLER_SPECIAL; if (startswith (tokstart, "new")) return NEW; if (startswith (tokstart, "int")) -- 2.55.0