From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from simark.ca by simark.ca with LMTP id AIKPKgaZ71/2TAAAWB0awg (envelope-from ) for ; Fri, 01 Jan 2021 16:49:58 -0500 Received: by simark.ca (Postfix, from userid 112) id 88F701F0BA; Fri, 1 Jan 2021 16:49:55 -0500 (EST) X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on simark.ca X-Spam-Level: ** X-Spam-Status: No, score=2.4 required=5.0 tests=DKIM_SIGNED,MAILING_LIST_MULTI, RCVD_IN_BL_SPAMCOP_NET,RDNS_NONE,T_DKIM_INVALID,UPPERCASE_50_75, URIBL_BLOCKED autolearn=no autolearn_force=no version=3.4.2 Received: from sourceware.org (unknown [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by simark.ca (Postfix) with ESMTPS id 8C7B31F0C7 for ; Fri, 1 Jan 2021 16:49:45 -0500 (EST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5DCA2393BC29; Fri, 1 Jan 2021 21:49:11 +0000 (GMT) Received: from gateway33.websitewelcome.com (gateway33.websitewelcome.com [192.185.146.130]) by sourceware.org (Postfix) with ESMTPS id E30213938C3D for ; Fri, 1 Jan 2021 21:49:03 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org E30213938C3D Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=tromey.com Authentication-Results: sourceware.org; spf=fail smtp.mailfrom=tom@tromey.com Received: from cm13.websitewelcome.com (cm13.websitewelcome.com [100.42.49.6]) by gateway33.websitewelcome.com (Postfix) with ESMTP id 8519A32F3 for ; Fri, 1 Jan 2021 15:49:03 -0600 (CST) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id vSIBkZFGSoE4DvSIBkuHet; Fri, 01 Jan 2021 15:49:03 -0600 X-Authority-Reason: nr=8 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=tromey.com; s=default; h=Content-Transfer-Encoding:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Sender:Reply-To:Cc:Content-Type:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=gJvVpZc68AGzirnwSpppTMfqYhhC1vkwYtv5yJ5/0c0=; b=ha2Mg/0WOFZsaMrQYAnlc5zCdt /byUi3IyqBaLsmB9ppWkCap3oquJRTR/LIP4WQvUxBwNfX3Ue0/VmnjcmA93SCib3A/B+TI6VGNNg hOYG/7sh6kPbz07Muz3hxc/ad; Received: from 97-122-81-39.hlrn.qwest.net ([97.122.81.39]:60428 helo=localhost.localdomain) by box5379.bluehost.com with esmtpsa (TLS1.2) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.93) (envelope-from ) id 1kvSIB-002A3B-C0 for gdb-patches@sourceware.org; Fri, 01 Jan 2021 14:49:03 -0700 From: Tom Tromey To: gdb-patches@sourceware.org Subject: [PATCH 196/203] Remove BINOP_END Date: Fri, 1 Jan 2021 14:47:16 -0700 Message-Id: <20210101214723.1784144-197-tom@tromey.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20210101214723.1784144-1-tom@tromey.com> References: <20210101214723.1784144-1-tom@tromey.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-AntiAbuse: This header was added to track abuse, please include it with any abuse report X-AntiAbuse: Primary Hostname - box5379.bluehost.com X-AntiAbuse: Original Domain - sourceware.org X-AntiAbuse: Originator/Caller UID/GID - [47 12] / [47 12] X-AntiAbuse: Sender Address Domain - tromey.com X-BWhitelist: no X-Source-IP: 97.122.81.39 X-Source-L: No X-Exim-ID: 1kvSIB-002A3B-C0 X-Source: X-Source-Args: X-Source-Dir: X-Source-Sender: 97-122-81-39.hlrn.qwest.net (localhost.localdomain) [97.122.81.39]:60428 X-Source-Auth: tom+tromey.com X-Email-Count: 197 X-Source-Cap: ZWx5bnJvYmk7ZWx5bnJvYmk7Ym94NTM3OS5ibHVlaG9zdC5jb20= X-Local-Domain: yes X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces@sourceware.org Sender: "Gdb-patches" BINOP_END is used only as a "meaningless" value in various tables. This patch changes these to use OP_NULL instead, and removes BINOP_END. gdb/ChangeLog 2021-01-01 Tom Tromey * std-operator.def (BINOP_END): Remove. * p-exp.y (tokentab3, tokentab2): Use OP_NULL, not BINOP_END. * go-exp.y (tokentab2): Use OP_NULL, not BINOP_END. * f-exp.y (dot_ops, f77_keywords): Use OP_NULL, not BINOP_END. * d-exp.y (tokentab2, ident_tokens): Use OP_NULL, not BINOP_END. * c-exp.y (tokentab3, tokentab2, ident_tokens): Use OP_NULL, not BINOP_END. --- gdb/ChangeLog | 10 ++++++++ gdb/c-exp.y | 36 +++++++++++++------------- gdb/d-exp.y | 28 ++++++++++----------- gdb/f-exp.y | 60 ++++++++++++++++++++++---------------------- gdb/go-exp.y | 26 +++++++++---------- gdb/p-exp.y | 30 +++++++++++----------- gdb/std-operator.def | 3 --- 7 files changed, 100 insertions(+), 93 deletions(-) diff --git a/gdb/c-exp.y b/gdb/c-exp.y index 37a7f2c9e56..3ce08838080 100644 --- a/gdb/c-exp.y +++ b/gdb/c-exp.y @@ -2479,8 +2479,8 @@ static const struct token tokentab3[] = { {">>=", ASSIGN_MODIFY, BINOP_RSH, 0}, {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0}, - {"->*", ARROW_STAR, BINOP_END, FLAG_CXX}, - {"...", DOTDOTDOT, BINOP_END, 0} + {"->*", ARROW_STAR, OP_NULL, FLAG_CXX}, + {"...", DOTDOTDOT, OP_NULL, 0} }; static const struct token tokentab2[] = @@ -2493,21 +2493,21 @@ static const struct token tokentab2[] = {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0}, {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0}, {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0}, - {"++", INCREMENT, BINOP_END, 0}, - {"--", DECREMENT, BINOP_END, 0}, - {"->", ARROW, BINOP_END, 0}, - {"&&", ANDAND, BINOP_END, 0}, - {"||", OROR, BINOP_END, 0}, + {"++", INCREMENT, OP_NULL, 0}, + {"--", DECREMENT, OP_NULL, 0}, + {"->", ARROW, OP_NULL, 0}, + {"&&", ANDAND, OP_NULL, 0}, + {"||", OROR, OP_NULL, 0}, /* "::" is *not* only C++: gdb overrides its meaning in several different ways, e.g., 'filename'::func, function::variable. */ - {"::", COLONCOLON, BINOP_END, 0}, - {"<<", LSH, BINOP_END, 0}, - {">>", RSH, BINOP_END, 0}, - {"==", EQUAL, BINOP_END, 0}, - {"!=", NOTEQUAL, BINOP_END, 0}, - {"<=", LEQ, BINOP_END, 0}, - {">=", GEQ, BINOP_END, 0}, - {".*", DOT_STAR, BINOP_END, FLAG_CXX} + {"::", COLONCOLON, OP_NULL, 0}, + {"<<", LSH, OP_NULL, 0}, + {">>", RSH, OP_NULL, 0}, + {"==", EQUAL, OP_NULL, 0}, + {"!=", NOTEQUAL, OP_NULL, 0}, + {"<=", LEQ, OP_NULL, 0}, + {">=", GEQ, OP_NULL, 0}, + {".*", DOT_STAR, OP_NULL, FLAG_CXX} }; /* Identifier-like tokens. Only type-specifiers than can appear in @@ -2546,14 +2546,14 @@ static const struct token ident_tokens[] = {"delete", DELETE, OP_NULL, FLAG_CXX}, {"operator", OPERATOR, OP_NULL, FLAG_CXX}, - {"and", ANDAND, BINOP_END, FLAG_CXX}, + {"and", ANDAND, OP_NULL, FLAG_CXX}, {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX}, {"bitand", '&', OP_NULL, FLAG_CXX}, {"bitor", '|', OP_NULL, FLAG_CXX}, {"compl", '~', OP_NULL, FLAG_CXX}, {"not", '!', OP_NULL, FLAG_CXX}, - {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX}, - {"or", OROR, BINOP_END, FLAG_CXX}, + {"not_eq", NOTEQUAL, OP_NULL, FLAG_CXX}, + {"or", OROR, OP_NULL, FLAG_CXX}, {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX}, {"xor", '^', OP_NULL, FLAG_CXX}, {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX}, diff --git a/gdb/d-exp.y b/gdb/d-exp.y index 61ddb983d64..d79eaf14a8f 100644 --- a/gdb/d-exp.y +++ b/gdb/d-exp.y @@ -965,25 +965,25 @@ static const struct token tokentab2[] = {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, - {"++", INCREMENT, BINOP_END}, - {"--", DECREMENT, BINOP_END}, - {"&&", ANDAND, BINOP_END}, - {"||", OROR, BINOP_END}, - {"^^", HATHAT, BINOP_END}, - {"<<", LSH, BINOP_END}, - {">>", RSH, BINOP_END}, - {"==", EQUAL, BINOP_END}, - {"!=", NOTEQUAL, BINOP_END}, - {"<=", LEQ, BINOP_END}, - {">=", GEQ, BINOP_END}, - {"..", DOTDOT, BINOP_END}, + {"++", INCREMENT, OP_NULL}, + {"--", DECREMENT, OP_NULL}, + {"&&", ANDAND, OP_NULL}, + {"||", OROR, OP_NULL}, + {"^^", HATHAT, OP_NULL}, + {"<<", LSH, OP_NULL}, + {">>", RSH, OP_NULL}, + {"==", EQUAL, OP_NULL}, + {"!=", NOTEQUAL, OP_NULL}, + {"<=", LEQ, OP_NULL}, + {">=", GEQ, OP_NULL}, + {"..", DOTDOT, OP_NULL}, }; /* Identifier-like tokens. */ static const struct token ident_tokens[] = { - {"is", IDENTITY, BINOP_END}, - {"!is", NOTIDENTITY, BINOP_END}, + {"is", IDENTITY, OP_NULL}, + {"!is", NOTIDENTITY, OP_NULL}, {"cast", CAST_KEYWORD, OP_NULL}, {"const", CONST_KEYWORD, OP_NULL}, diff --git a/gdb/f-exp.y b/gdb/f-exp.y index 3aee19facce..29575f90a3a 100644 --- a/gdb/f-exp.y +++ b/gdb/f-exp.y @@ -1019,17 +1019,17 @@ struct token static const struct token dot_ops[] = { - { ".and.", BOOL_AND, BINOP_END, false }, - { ".or.", BOOL_OR, BINOP_END, false }, - { ".not.", BOOL_NOT, BINOP_END, false }, - { ".eq.", EQUAL, BINOP_END, false }, - { ".eqv.", EQUAL, BINOP_END, false }, - { ".neqv.", NOTEQUAL, BINOP_END, false }, - { ".ne.", NOTEQUAL, BINOP_END, false }, - { ".le.", LEQ, BINOP_END, false }, - { ".ge.", GEQ, BINOP_END, false }, - { ".gt.", GREATERTHAN, BINOP_END, false }, - { ".lt.", LESSTHAN, BINOP_END, false }, + { ".and.", BOOL_AND, OP_NULL, false }, + { ".or.", BOOL_OR, OP_NULL, false }, + { ".not.", BOOL_NOT, OP_NULL, false }, + { ".eq.", EQUAL, OP_NULL, false }, + { ".eqv.", EQUAL, OP_NULL, false }, + { ".neqv.", NOTEQUAL, OP_NULL, false }, + { ".ne.", NOTEQUAL, OP_NULL, false }, + { ".le.", LEQ, OP_NULL, false }, + { ".ge.", GEQ, OP_NULL, false }, + { ".gt.", GREATERTHAN, OP_NULL, false }, + { ".lt.", LESSTHAN, OP_NULL, false }, }; /* Holds the Fortran representation of a boolean, and the integer value we @@ -1053,27 +1053,27 @@ static const struct f77_boolean_val boolean_values[] = static const struct token f77_keywords[] = { /* Historically these have always been lowercase only in GDB. */ - { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END, true }, - { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END, true }, - { "character", CHARACTER, BINOP_END, true }, - { "integer_2", INT_S2_KEYWORD, BINOP_END, true }, - { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END, true }, - { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END, true }, - { "logical_8", LOGICAL_S8_KEYWORD, BINOP_END, true }, - { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END, true }, - { "integer", INT_KEYWORD, BINOP_END, true }, - { "logical", LOGICAL_KEYWORD, BINOP_END, true }, - { "real_16", REAL_S16_KEYWORD, BINOP_END, true }, - { "complex", COMPLEX_KEYWORD, BINOP_END, true }, - { "sizeof", SIZEOF, BINOP_END, true }, - { "real_8", REAL_S8_KEYWORD, BINOP_END, true }, - { "real", REAL_KEYWORD, BINOP_END, true }, - { "single", SINGLE, BINOP_END, true }, - { "double", DOUBLE, BINOP_END, true }, - { "precision", PRECISION, BINOP_END, true }, + { "complex_16", COMPLEX_S16_KEYWORD, OP_NULL, true }, + { "complex_32", COMPLEX_S32_KEYWORD, OP_NULL, true }, + { "character", CHARACTER, OP_NULL, true }, + { "integer_2", INT_S2_KEYWORD, OP_NULL, true }, + { "logical_1", LOGICAL_S1_KEYWORD, OP_NULL, true }, + { "logical_2", LOGICAL_S2_KEYWORD, OP_NULL, true }, + { "logical_8", LOGICAL_S8_KEYWORD, OP_NULL, true }, + { "complex_8", COMPLEX_S8_KEYWORD, OP_NULL, true }, + { "integer", INT_KEYWORD, OP_NULL, true }, + { "logical", LOGICAL_KEYWORD, OP_NULL, true }, + { "real_16", REAL_S16_KEYWORD, OP_NULL, true }, + { "complex", COMPLEX_KEYWORD, OP_NULL, true }, + { "sizeof", SIZEOF, OP_NULL, true }, + { "real_8", REAL_S8_KEYWORD, OP_NULL, true }, + { "real", REAL_KEYWORD, OP_NULL, true }, + { "single", SINGLE, OP_NULL, true }, + { "double", DOUBLE, OP_NULL, true }, + { "precision", PRECISION, OP_NULL, true }, /* The following correspond to actual functions in Fortran and are case insensitive. */ - { "kind", KIND, BINOP_END, false }, + { "kind", KIND, OP_NULL, false }, { "abs", UNOP_INTRINSIC, UNOP_ABS, false }, { "mod", BINOP_INTRINSIC, BINOP_MOD, false }, { "floor", UNOP_INTRINSIC, UNOP_FORTRAN_FLOOR, false }, diff --git a/gdb/go-exp.y b/gdb/go-exp.y index 6e070a7f4ff..d096cc8b7c9 100644 --- a/gdb/go-exp.y +++ b/gdb/go-exp.y @@ -966,19 +966,19 @@ static const struct token tokentab2[] = {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR}, {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND}, {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR}, - {"++", INCREMENT, BINOP_END}, - {"--", DECREMENT, BINOP_END}, - /*{"->", RIGHT_ARROW, BINOP_END}, Doesn't exist in Go. */ - {"<-", LEFT_ARROW, BINOP_END}, - {"&&", ANDAND, BINOP_END}, - {"||", OROR, BINOP_END}, - {"<<", LSH, BINOP_END}, - {">>", RSH, BINOP_END}, - {"==", EQUAL, BINOP_END}, - {"!=", NOTEQUAL, BINOP_END}, - {"<=", LEQ, BINOP_END}, - {">=", GEQ, BINOP_END}, - /*{"&^", ANDNOT, BINOP_END}, TODO */ + {"++", INCREMENT, OP_NULL}, + {"--", DECREMENT, OP_NULL}, + /*{"->", RIGHT_ARROW, OP_NULL}, Doesn't exist in Go. */ + {"<-", LEFT_ARROW, OP_NULL}, + {"&&", ANDAND, OP_NULL}, + {"||", OROR, OP_NULL}, + {"<<", LSH, OP_NULL}, + {">>", RSH, OP_NULL}, + {"==", EQUAL, OP_NULL}, + {"!=", NOTEQUAL, OP_NULL}, + {"<=", LEQ, OP_NULL}, + {">=", GEQ, OP_NULL}, + /*{"&^", ANDNOT, OP_NULL}, TODO */ }; /* Identifier-like tokens. */ diff --git a/gdb/p-exp.y b/gdb/p-exp.y index 87fabc2ec11..4ac2f1f268d 100644 --- a/gdb/p-exp.y +++ b/gdb/p-exp.y @@ -1050,25 +1050,25 @@ struct token static const struct token tokentab3[] = { - {"shr", RSH, BINOP_END}, - {"shl", LSH, BINOP_END}, - {"and", ANDAND, BINOP_END}, - {"div", DIV, BINOP_END}, - {"not", NOT, BINOP_END}, - {"mod", MOD, BINOP_END}, - {"inc", INCREMENT, BINOP_END}, - {"dec", DECREMENT, BINOP_END}, - {"xor", XOR, BINOP_END} + {"shr", RSH, OP_NULL}, + {"shl", LSH, OP_NULL}, + {"and", ANDAND, OP_NULL}, + {"div", DIV, OP_NULL}, + {"not", NOT, OP_NULL}, + {"mod", MOD, OP_NULL}, + {"inc", INCREMENT, OP_NULL}, + {"dec", DECREMENT, OP_NULL}, + {"xor", XOR, OP_NULL} }; static const struct token tokentab2[] = { - {"or", OR, BINOP_END}, - {"<>", NOTEQUAL, BINOP_END}, - {"<=", LEQ, BINOP_END}, - {">=", GEQ, BINOP_END}, - {":=", ASSIGN, BINOP_END}, - {"::", COLONCOLON, BINOP_END} }; + {"or", OR, OP_NULL}, + {"<>", NOTEQUAL, OP_NULL}, + {"<=", LEQ, OP_NULL}, + {">=", GEQ, OP_NULL}, + {":=", ASSIGN, OP_NULL}, + {"::", COLONCOLON, OP_NULL} }; /* Allocate uppercased var: */ /* make an uppercased copy of tokstart. */ diff --git a/gdb/std-operator.def b/gdb/std-operator.def index 980f9cd7850..c60d60b976f 100644 --- a/gdb/std-operator.def +++ b/gdb/std-operator.def @@ -87,9 +87,6 @@ OP (BINOP_VAL) the second operand with itself that many times. */ OP (BINOP_CONCAT) -/* This must be the highest BINOP_ value, for expprint.c. */ -OP (BINOP_END) - /* Operates on three values computed by following subexpressions. */ OP (TERNOP_COND) /* ?: */ -- 2.26.2