From patchwork Sat Mar 22 04:43:46 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sergio Durigan Junior X-Patchwork-Id: 226 Return-Path: X-Original-To: siddhesh@wilcox.dreamhost.com Delivered-To: siddhesh@wilcox.dreamhost.com Received: from homiemail-mx21.g.dreamhost.com (caibbdcaaahb.dreamhost.com [208.113.200.71]) by wilcox.dreamhost.com (Postfix) with ESMTP id A31BC3600C2 for ; Fri, 21 Mar 2014 21:44:46 -0700 (PDT) Received: by homiemail-mx21.g.dreamhost.com (Postfix, from userid 14314964) id 5D84CC78802; Fri, 21 Mar 2014 21:44:46 -0700 (PDT) X-Original-To: gdb@patchwork.siddhesh.in Delivered-To: x14314964@homiemail-mx21.g.dreamhost.com Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by homiemail-mx21.g.dreamhost.com (Postfix) with ESMTPS id 2F2C1C60477 for ; Fri, 21 Mar 2014 21:44:46 -0700 (PDT) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=Gle0cNNyvvEhWUbJUjQcxaIin+VIaxn A+iB6blf+Nzc7Tbb21mVViuKgjCVeez2X0lzGpZQ/P+gVUvVQ77ivohGr6dcMg2T ZaVwIBWDZPOEMQYhq7U+3BFIt0akBjXWwYkqwykW+J0tCy6ERuzEbUGoqgLjJBOn ANsbRQeCwqV0= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; s=default; bh=lT5lMDH0KxAcxAJdzbwq9xntRvQ=; b=giyi9 +MoT4ALuzgRCLqPeY/ox+aFTu22J+80AMAlJ1eVgGg5dwPoh0hGNhQzaEf3s2G0x 6H4qe48+eh1jTkAUX2PoICzDxiy61fPhtxpo9LQPO8WMofsrVTvGVibtkrNj/fV3 gl4cBGaI4F9yS3ivlmugdn49b1TD7bmNiEYHlA= Received: (qmail 31165 invoked by alias); 22 Mar 2014 04:44:26 -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 31071 invoked by uid 89); 22 Mar 2014 04:44:25 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.2 required=5.0 tests=AWL, BAYES_00, KAM_STOCKGEN, SPF_HELO_PASS, SPF_PASS, T_RP_MATCHES_RCVD, UNWANTED_LANGUAGE_BODY autolearn=no version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 22 Mar 2014 04:44:18 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s2M4iHiq004870 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Sat, 22 Mar 2014 00:44:17 -0400 Received: from psique.redhat.com (ovpn-113-73.phx2.redhat.com [10.3.113.73]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s2M4i8XF001988; Sat, 22 Mar 2014 00:44:15 -0400 From: Sergio Durigan Junior To: GDB Patches Cc: Tom Tromey , Sergio Durigan Junior Subject: [PATCH v4 04/10] Ada language. Date: Sat, 22 Mar 2014 01:43:46 -0300 Message-Id: <1395463432-29750-5-git-send-email-sergiodj@redhat.com> In-Reply-To: <1395463432-29750-1-git-send-email-sergiodj@redhat.com> References: <1395463432-29750-1-git-send-email-sergiodj@redhat.com> X-IsSubscribed: yes X-DH-Original-To: gdb@patchwork.siddhesh.in Patch for the Ada language. This one is a bit different than the other patches because it uses its own lexer, so I had to hack it too. 2014-03-22 Sergio Durigan Junior * ada-exp.y (parse_type): Rewrite macro to use parser state. (yyparse): Redefine macro to ada_parse_internal. (pstate): New variable. (write_int, write_object_renaming, write_var_or_type, write_name_assoc, write_exp_op_with_string, write_ambiguous_var, type_int, type_long, type_long_long, type_float, type_double, type_long_double, type_char, type_boolean, type_system_address): Add "struct parser_state" argument. (exp1, primary, simple_exp, relation, and_exp, and_then_exp, or_exp, or_else_exp, xor_exp, type_prefix, opt_type_prefix, var_or_type, aggregate, aggregate_component_list, positional_list, others, component_group, component_associations): Update calls to write_exp* and similar functions in order to use parser state. (ada_parse, write_var_from_sym, write_int, write_exp_op_with_string, write_object_renaming, find_primitive_type, write_selectors, write_ambiguous_var, write_var_or_type, write_name_assoc, type_int, type_long, type_long_long, type_float, type_double, type_long_double, type_char, type_boolean, type_system_address): Add "struct parser_state" argument. Adjust function to use parser state. * ada-lang.c (parse): Likewise. * ada-lang.h: Forward declare "struct parser_state". (ada_parse): Add "struct parser_state" argument. * ada-lex.l (processInt, processReal): Likewise. Adjust all calls to both functions. --- gdb/ada-exp.y | 488 ++++++++++++++++++++++++++++++--------------------------- gdb/ada-lang.c | 4 +- gdb/ada-lang.h | 3 +- gdb/ada-lex.l | 54 ++++--- 4 files changed, 294 insertions(+), 255 deletions(-) diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index 4273f1d..aa74429 100644 --- a/gdb/ada-exp.y +++ b/gdb/ada-exp.y @@ -49,7 +49,7 @@ #include "frame.h" #include "block.h" -#define parse_type builtin_type (parse_gdbarch) +#define parse_type(ps) builtin_type (parse_gdbarch (ps)) /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), as well as gratuitiously global symbol names, so we can have multiple @@ -63,7 +63,8 @@ without BISON? (PNH) */ #define yymaxdepth ada_maxdepth -#define yyparse _ada_parse /* ada_parse calls this after initialization */ +/* ada_parse calls this after initialization */ +#define yyparse ada_parse_internal #define yylex ada_lex #define yyerror ada_error #define yylval ada_lval @@ -113,6 +114,11 @@ struct name_info { struct stoken stoken; }; +/* The state of the parser, used internally when we are parsing the + expression. */ + +static struct parser_state *pstate = NULL; + static struct stoken empty_stoken = { "", 0 }; /* If expression is in the context of TYPE'(...), then TYPE, else @@ -125,40 +131,44 @@ static int yylex (void); void yyerror (char *); -static void write_int (LONGEST, struct type *); +static void write_int (struct parser_state *, LONGEST, struct type *); -static void write_object_renaming (const struct block *, const char *, int, +static void write_object_renaming (struct parser_state *, + const struct block *, const char *, int, const char *, int); -static struct type* write_var_or_type (const struct block *, struct stoken); +static struct type* write_var_or_type (struct parser_state *, + const struct block *, struct stoken); -static void write_name_assoc (struct stoken); +static void write_name_assoc (struct parser_state *, struct stoken); -static void write_exp_op_with_string (enum exp_opcode, struct stoken); +static void write_exp_op_with_string (struct parser_state *, enum exp_opcode, + struct stoken); static struct block *block_lookup (struct block *, const char *); static LONGEST convert_char_literal (struct type *, LONGEST); -static void write_ambiguous_var (const struct block *, char *, int); +static void write_ambiguous_var (struct parser_state *, + const struct block *, char *, int); -static struct type *type_int (void); +static struct type *type_int (struct parser_state *); -static struct type *type_long (void); +static struct type *type_long (struct parser_state *); -static struct type *type_long_long (void); +static struct type *type_long_long (struct parser_state *); -static struct type *type_float (void); +static struct type *type_float (struct parser_state *); -static struct type *type_double (void); +static struct type *type_double (struct parser_state *); -static struct type *type_long_double (void); +static struct type *type_long_double (struct parser_state *); -static struct type *type_char (void); +static struct type *type_char (struct parser_state *); -static struct type *type_boolean (void); +static struct type *type_boolean (struct parser_state *); -static struct type *type_system_address (void); +static struct type *type_system_address (struct parser_state *); %} @@ -234,25 +244,26 @@ start : exp1 /* Expressions, including the sequencing operator. */ exp1 : exp | exp1 ';' exp - { write_exp_elt_opcode (BINOP_COMMA); } + { write_exp_elt_opcode (pstate, BINOP_COMMA); } | primary ASSIGN exp /* Extension for convenience */ - { write_exp_elt_opcode (BINOP_ASSIGN); } + { write_exp_elt_opcode (pstate, BINOP_ASSIGN); } ; /* Expressions, not including the sequencing operator. */ primary : primary DOT_ALL - { write_exp_elt_opcode (UNOP_IND); } + { write_exp_elt_opcode (pstate, UNOP_IND); } ; primary : primary DOT_ID - { write_exp_op_with_string (STRUCTOP_STRUCT, $2); } + { write_exp_op_with_string (pstate, STRUCTOP_STRUCT, + $2); } ; primary : primary '(' arglist ')' { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ($3); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (pstate, OP_FUNCALL); + write_exp_elt_longcst (pstate, $3); + write_exp_elt_opcode (pstate, OP_FUNCALL); } | var_or_type '(' arglist ')' { @@ -260,15 +271,15 @@ primary : primary '(' arglist ')' { if ($3 != 1) error (_("Invalid conversion")); - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type ($1); - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (pstate, UNOP_CAST); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, UNOP_CAST); } else { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ($3); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (pstate, OP_FUNCALL); + write_exp_elt_longcst (pstate, $3); + write_exp_elt_opcode (pstate, OP_FUNCALL); } } ; @@ -278,9 +289,9 @@ primary : var_or_type '\'' save_qualifier { type_qualifier = $1; } { if ($1 == NULL) error (_("Type required for qualification")); - write_exp_elt_opcode (UNOP_QUAL); - write_exp_elt_type ($1); - write_exp_elt_opcode (UNOP_QUAL); + write_exp_elt_opcode (pstate, UNOP_QUAL); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, UNOP_QUAL); type_qualifier = $3; } ; @@ -290,10 +301,10 @@ save_qualifier : { $$ = type_qualifier; } primary : primary '(' simple_exp DOTDOT simple_exp ')' - { write_exp_elt_opcode (TERNOP_SLICE); } + { write_exp_elt_opcode (pstate, TERNOP_SLICE); } | var_or_type '(' simple_exp DOTDOT simple_exp ')' { if ($1 == NULL) - write_exp_elt_opcode (TERNOP_SLICE); + write_exp_elt_opcode (pstate, TERNOP_SLICE); else error (_("Cannot slice a type")); } @@ -313,15 +324,15 @@ primary : '(' exp1 ')' { } primary : var_or_type %prec VAR { if ($1 != NULL) { - write_exp_elt_opcode (OP_TYPE); - write_exp_elt_type ($1); - write_exp_elt_opcode (OP_TYPE); + write_exp_elt_opcode (pstate, OP_TYPE); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, OP_TYPE); } } ; primary : SPECIAL_VARIABLE /* Various GDB extensions */ - { write_dollar_variable ($1); } + { write_dollar_variable (pstate, $1); } ; primary : aggregate @@ -331,19 +342,19 @@ simple_exp : primary ; simple_exp : '-' simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_NEG); } + { write_exp_elt_opcode (pstate, UNOP_NEG); } ; simple_exp : '+' simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_PLUS); } + { write_exp_elt_opcode (pstate, UNOP_PLUS); } ; simple_exp : NOT simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } + { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } ; simple_exp : ABS simple_exp %prec UNARY - { write_exp_elt_opcode (UNOP_ABS); } + { write_exp_elt_opcode (pstate, UNOP_ABS); } ; arglist : { $$ = 0; } @@ -364,111 +375,111 @@ primary : '{' var_or_type '}' primary %prec '.' { if ($2 == NULL) error (_("Type required within braces in coercion")); - write_exp_elt_opcode (UNOP_MEMVAL); - write_exp_elt_type ($2); - write_exp_elt_opcode (UNOP_MEMVAL); + write_exp_elt_opcode (pstate, UNOP_MEMVAL); + write_exp_elt_type (pstate, $2); + write_exp_elt_opcode (pstate, UNOP_MEMVAL); } ; /* Binary operators in order of decreasing precedence. */ simple_exp : simple_exp STARSTAR simple_exp - { write_exp_elt_opcode (BINOP_EXP); } + { write_exp_elt_opcode (pstate, BINOP_EXP); } ; simple_exp : simple_exp '*' simple_exp - { write_exp_elt_opcode (BINOP_MUL); } + { write_exp_elt_opcode (pstate, BINOP_MUL); } ; simple_exp : simple_exp '/' simple_exp - { write_exp_elt_opcode (BINOP_DIV); } + { write_exp_elt_opcode (pstate, BINOP_DIV); } ; simple_exp : simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */ - { write_exp_elt_opcode (BINOP_REM); } + { write_exp_elt_opcode (pstate, BINOP_REM); } ; simple_exp : simple_exp MOD simple_exp - { write_exp_elt_opcode (BINOP_MOD); } + { write_exp_elt_opcode (pstate, BINOP_MOD); } ; simple_exp : simple_exp '@' simple_exp /* GDB extension */ - { write_exp_elt_opcode (BINOP_REPEAT); } + { write_exp_elt_opcode (pstate, BINOP_REPEAT); } ; simple_exp : simple_exp '+' simple_exp - { write_exp_elt_opcode (BINOP_ADD); } + { write_exp_elt_opcode (pstate, BINOP_ADD); } ; simple_exp : simple_exp '&' simple_exp - { write_exp_elt_opcode (BINOP_CONCAT); } + { write_exp_elt_opcode (pstate, BINOP_CONCAT); } ; simple_exp : simple_exp '-' simple_exp - { write_exp_elt_opcode (BINOP_SUB); } + { write_exp_elt_opcode (pstate, BINOP_SUB); } ; relation : simple_exp ; relation : simple_exp '=' simple_exp - { write_exp_elt_opcode (BINOP_EQUAL); } + { write_exp_elt_opcode (pstate, BINOP_EQUAL); } ; relation : simple_exp NOTEQUAL simple_exp - { write_exp_elt_opcode (BINOP_NOTEQUAL); } + { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); } ; relation : simple_exp LEQ simple_exp - { write_exp_elt_opcode (BINOP_LEQ); } + { write_exp_elt_opcode (pstate, BINOP_LEQ); } ; relation : simple_exp IN simple_exp DOTDOT simple_exp - { write_exp_elt_opcode (TERNOP_IN_RANGE); } + { write_exp_elt_opcode (pstate, TERNOP_IN_RANGE); } | simple_exp IN primary TICK_RANGE tick_arglist - { write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_longcst ((LONGEST) $5); - write_exp_elt_opcode (BINOP_IN_BOUNDS); + { write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS); + write_exp_elt_longcst (pstate, (LONGEST) $5); + write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS); } | simple_exp IN var_or_type %prec TICK_ACCESS { if ($3 == NULL) error (_("Right operand of 'in' must be type")); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_type ($3); - write_exp_elt_opcode (UNOP_IN_RANGE); + write_exp_elt_opcode (pstate, UNOP_IN_RANGE); + write_exp_elt_type (pstate, $3); + write_exp_elt_opcode (pstate, UNOP_IN_RANGE); } | simple_exp NOT IN simple_exp DOTDOT simple_exp - { write_exp_elt_opcode (TERNOP_IN_RANGE); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + { write_exp_elt_opcode (pstate, TERNOP_IN_RANGE); + write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } | simple_exp NOT IN primary TICK_RANGE tick_arglist - { write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_longcst ((LONGEST) $6); - write_exp_elt_opcode (BINOP_IN_BOUNDS); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + { write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS); + write_exp_elt_longcst (pstate, (LONGEST) $6); + write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS); + write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } | simple_exp NOT IN var_or_type %prec TICK_ACCESS { if ($4 == NULL) error (_("Right operand of 'in' must be type")); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_type ($4); - write_exp_elt_opcode (UNOP_IN_RANGE); - write_exp_elt_opcode (UNOP_LOGICAL_NOT); + write_exp_elt_opcode (pstate, UNOP_IN_RANGE); + write_exp_elt_type (pstate, $4); + write_exp_elt_opcode (pstate, UNOP_IN_RANGE); + write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } ; relation : simple_exp GEQ simple_exp - { write_exp_elt_opcode (BINOP_GEQ); } + { write_exp_elt_opcode (pstate, BINOP_GEQ); } ; relation : simple_exp '<' simple_exp - { write_exp_elt_opcode (BINOP_LESS); } + { write_exp_elt_opcode (pstate, BINOP_LESS); } ; relation : simple_exp '>' simple_exp - { write_exp_elt_opcode (BINOP_GTR); } + { write_exp_elt_opcode (pstate, BINOP_GTR); } ; exp : relation @@ -481,36 +492,36 @@ exp : relation and_exp : relation _AND_ relation - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); } | and_exp _AND_ relation - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); } ; and_then_exp : relation _AND_ THEN relation - { write_exp_elt_opcode (BINOP_LOGICAL_AND); } + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); } | and_then_exp _AND_ THEN relation - { write_exp_elt_opcode (BINOP_LOGICAL_AND); } + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); } ; or_exp : relation OR relation - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); } | or_exp OR relation - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); } ; or_else_exp : relation OR ELSE relation - { write_exp_elt_opcode (BINOP_LOGICAL_OR); } + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); } | or_else_exp OR ELSE relation - { write_exp_elt_opcode (BINOP_LOGICAL_OR); } + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); } ; xor_exp : relation XOR relation - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); } | xor_exp XOR relation - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); } ; /* Primaries can denote types (OP_TYPE). In cases such as @@ -522,36 +533,37 @@ xor_exp : relation XOR relation aType'access evaluates to a type that evaluate_subexp attempts to evaluate. */ primary : primary TICK_ACCESS - { write_exp_elt_opcode (UNOP_ADDR); } + { write_exp_elt_opcode (pstate, UNOP_ADDR); } | primary TICK_ADDRESS - { write_exp_elt_opcode (UNOP_ADDR); - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type (type_system_address ()); - write_exp_elt_opcode (UNOP_CAST); + { write_exp_elt_opcode (pstate, UNOP_ADDR); + write_exp_elt_opcode (pstate, UNOP_CAST); + write_exp_elt_type (pstate, + type_system_address (pstate)); + write_exp_elt_opcode (pstate, UNOP_CAST); } | primary TICK_FIRST tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_FIRST); } + { write_int (pstate, $3, type_int (pstate)); + write_exp_elt_opcode (pstate, OP_ATR_FIRST); } | primary TICK_LAST tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_LAST); } + { write_int (pstate, $3, type_int (pstate)); + write_exp_elt_opcode (pstate, OP_ATR_LAST); } | primary TICK_LENGTH tick_arglist - { write_int ($3, type_int ()); - write_exp_elt_opcode (OP_ATR_LENGTH); } + { write_int (pstate, $3, type_int (pstate)); + write_exp_elt_opcode (pstate, OP_ATR_LENGTH); } | primary TICK_SIZE - { write_exp_elt_opcode (OP_ATR_SIZE); } + { write_exp_elt_opcode (pstate, OP_ATR_SIZE); } | primary TICK_TAG - { write_exp_elt_opcode (OP_ATR_TAG); } + { write_exp_elt_opcode (pstate, OP_ATR_TAG); } | opt_type_prefix TICK_MIN '(' exp ',' exp ')' - { write_exp_elt_opcode (OP_ATR_MIN); } + { write_exp_elt_opcode (pstate, OP_ATR_MIN); } | opt_type_prefix TICK_MAX '(' exp ',' exp ')' - { write_exp_elt_opcode (OP_ATR_MAX); } + { write_exp_elt_opcode (pstate, OP_ATR_MAX); } | opt_type_prefix TICK_POS '(' exp ')' - { write_exp_elt_opcode (OP_ATR_POS); } + { write_exp_elt_opcode (pstate, OP_ATR_POS); } | type_prefix TICK_VAL '(' exp ')' - { write_exp_elt_opcode (OP_ATR_VAL); } + { write_exp_elt_opcode (pstate, OP_ATR_VAL); } | type_prefix TICK_MODULUS - { write_exp_elt_opcode (OP_ATR_MODULUS); } + { write_exp_elt_opcode (pstate, OP_ATR_MODULUS); } ; tick_arglist : %prec '(' @@ -565,53 +577,55 @@ type_prefix : { if ($1 == NULL) error (_("Prefix must be type")); - write_exp_elt_opcode (OP_TYPE); - write_exp_elt_type ($1); - write_exp_elt_opcode (OP_TYPE); } + write_exp_elt_opcode (pstate, OP_TYPE); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, OP_TYPE); } ; opt_type_prefix : type_prefix | /* EMPTY */ - { write_exp_elt_opcode (OP_TYPE); - write_exp_elt_type (parse_type->builtin_void); - write_exp_elt_opcode (OP_TYPE); } + { write_exp_elt_opcode (pstate, OP_TYPE); + write_exp_elt_type (pstate, + parse_type (pstate)->builtin_void); + write_exp_elt_opcode (pstate, OP_TYPE); } ; primary : INT - { write_int ((LONGEST) $1.val, $1.type); } + { write_int (pstate, (LONGEST) $1.val, $1.type); } ; primary : CHARLIT - { write_int (convert_char_literal (type_qualifier, $1.val), + { write_int (pstate, + convert_char_literal (type_qualifier, $1.val), (type_qualifier == NULL) ? $1.type : type_qualifier); } ; primary : FLOAT - { write_exp_elt_opcode (OP_DOUBLE); - write_exp_elt_type ($1.type); - write_exp_elt_dblcst ($1.dval); - write_exp_elt_opcode (OP_DOUBLE); + { write_exp_elt_opcode (pstate, OP_DOUBLE); + write_exp_elt_type (pstate, $1.type); + write_exp_elt_dblcst (pstate, $1.dval); + write_exp_elt_opcode (pstate, OP_DOUBLE); } ; primary : NULL_PTR - { write_int (0, type_int ()); } + { write_int (pstate, 0, type_int (pstate)); } ; primary : STRING { - write_exp_op_with_string (OP_STRING, $1); + write_exp_op_with_string (pstate, OP_STRING, $1); } ; primary : TRUEKEYWORD - { write_int (1, type_boolean ()); } + { write_int (pstate, 1, type_boolean (pstate)); } | FALSEKEYWORD - { write_int (0, type_boolean ()); } + { write_int (pstate, 0, type_boolean (pstate)); } ; primary : NEW NAME @@ -619,22 +633,22 @@ primary : NEW NAME ; var_or_type: NAME %prec VAR - { $$ = write_var_or_type (NULL, $1); } + { $$ = write_var_or_type (pstate, NULL, $1); } | block NAME %prec VAR - { $$ = write_var_or_type ($1, $2); } + { $$ = write_var_or_type (pstate, $1, $2); } | NAME TICK_ACCESS { - $$ = write_var_or_type (NULL, $1); + $$ = write_var_or_type (pstate, NULL, $1); if ($$ == NULL) - write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (pstate, UNOP_ADDR); else $$ = lookup_pointer_type ($$); } | block NAME TICK_ACCESS { - $$ = write_var_or_type ($1, $2); + $$ = write_var_or_type (pstate, $1, $2); if ($$ == NULL) - write_exp_elt_opcode (UNOP_ADDR); + write_exp_elt_opcode (pstate, UNOP_ADDR); else $$ = lookup_pointer_type ($$); } @@ -650,18 +664,18 @@ block : NAME COLONCOLON aggregate : '(' aggregate_component_list ')' { - write_exp_elt_opcode (OP_AGGREGATE); - write_exp_elt_longcst ($2); - write_exp_elt_opcode (OP_AGGREGATE); + write_exp_elt_opcode (pstate, OP_AGGREGATE); + write_exp_elt_longcst (pstate, $2); + write_exp_elt_opcode (pstate, OP_AGGREGATE); } ; aggregate_component_list : component_groups { $$ = $1; } | positional_list exp - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (pstate, OP_POSITIONAL); + write_exp_elt_longcst (pstate, $1); + write_exp_elt_opcode (pstate, OP_POSITIONAL); $$ = $1 + 1; } | positional_list component_groups @@ -670,15 +684,15 @@ aggregate_component_list : positional_list : exp ',' - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst (0); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (pstate, OP_POSITIONAL); + write_exp_elt_longcst (pstate, 0); + write_exp_elt_opcode (pstate, OP_POSITIONAL); $$ = 1; } | positional_list exp ',' - { write_exp_elt_opcode (OP_POSITIONAL); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_POSITIONAL); + { write_exp_elt_opcode (pstate, OP_POSITIONAL); + write_exp_elt_longcst (pstate, $1); + write_exp_elt_opcode (pstate, OP_POSITIONAL); $$ = $1 + 1; } ; @@ -691,15 +705,15 @@ component_groups: ; others : OTHERS ARROW exp - { write_exp_elt_opcode (OP_OTHERS); } + { write_exp_elt_opcode (pstate, OP_OTHERS); } ; component_group : component_associations { - write_exp_elt_opcode (OP_CHOICES); - write_exp_elt_longcst ($1); - write_exp_elt_opcode (OP_CHOICES); + write_exp_elt_opcode (pstate, OP_CHOICES); + write_exp_elt_longcst (pstate, $1); + write_exp_elt_opcode (pstate, OP_CHOICES); } ; @@ -710,22 +724,23 @@ component_group : resolved shift/reduce conflict. */ component_associations : NAME ARROW - { write_name_assoc ($1); } + { write_name_assoc (pstate, $1); } exp { $$ = 1; } | simple_exp ARROW exp { $$ = 1; } | simple_exp DOTDOT simple_exp ARROW - { write_exp_elt_opcode (OP_DISCRETE_RANGE); - write_exp_op_with_string (OP_NAME, empty_stoken); + { write_exp_elt_opcode (pstate, OP_DISCRETE_RANGE); + write_exp_op_with_string (pstate, OP_NAME, + empty_stoken); } exp { $$ = 1; } | NAME '|' - { write_name_assoc ($1); } + { write_name_assoc (pstate, $1); } component_associations { $$ = $4 + 1; } | simple_exp '|' component_associations { $$ = $3 + 1; } | simple_exp DOTDOT simple_exp '|' - { write_exp_elt_opcode (OP_DISCRETE_RANGE); } + { write_exp_elt_opcode (pstate, OP_DISCRETE_RANGE); } component_associations { $$ = $6 + 1; } ; @@ -733,11 +748,11 @@ component_associations : can't get used to Ada notation in GDB. */ primary : '*' primary %prec '.' - { write_exp_elt_opcode (UNOP_IND); } + { write_exp_elt_opcode (pstate, UNOP_IND); } | '&' primary %prec '.' - { write_exp_elt_opcode (UNOP_ADDR); } + { write_exp_elt_opcode (pstate, UNOP_ADDR); } | primary '[' exp ']' - { write_exp_elt_opcode (BINOP_SUBSCRIPT); } + { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); } ; %% @@ -768,14 +783,23 @@ static struct obstack temp_parse_space; #include "ada-lex.c" int -ada_parse (void) +ada_parse (struct parser_state *par_state) { + int result; + struct cleanup *c = make_cleanup_clear_parser_state (&pstate); + + /* Setting up the parser state. */ + gdb_assert (par_state != NULL); + pstate = par_state; + lexer_init (yyin); /* (Re-)initialize lexer. */ type_qualifier = NULL; obstack_free (&temp_parse_space, NULL); obstack_init (&temp_parse_space); - return _ada_parse (); + result = yyparse (); + do_cleanups (c); + return result; } void @@ -787,7 +811,8 @@ yyerror (char *msg) /* Emit expression to access an instance of SYM, in block BLOCK (if * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */ static void -write_var_from_sym (const struct block *orig_left_context, +write_var_from_sym (struct parser_state *par_state, + const struct block *orig_left_context, const struct block *block, struct symbol *sym) { @@ -798,30 +823,31 @@ write_var_from_sym (const struct block *orig_left_context, innermost_block = block; } - write_exp_elt_opcode (OP_VAR_VALUE); - write_exp_elt_block (block); - write_exp_elt_sym (sym); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (par_state, OP_VAR_VALUE); + write_exp_elt_block (par_state, block); + write_exp_elt_sym (par_state, sym); + write_exp_elt_opcode (par_state, OP_VAR_VALUE); } /* Write integer or boolean constant ARG of type TYPE. */ static void -write_int (LONGEST arg, struct type *type) +write_int (struct parser_state *par_state, LONGEST arg, struct type *type) { - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (type); - write_exp_elt_longcst (arg); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (par_state, OP_LONG); + write_exp_elt_type (par_state, type); + write_exp_elt_longcst (par_state, arg); + write_exp_elt_opcode (par_state, OP_LONG); } /* Write an OPCODE, string, OPCODE sequence to the current expression. */ static void -write_exp_op_with_string (enum exp_opcode opcode, struct stoken token) +write_exp_op_with_string (struct parser_state *par_state, + enum exp_opcode opcode, struct stoken token) { - write_exp_elt_opcode (opcode); - write_exp_string (token); - write_exp_elt_opcode (opcode); + write_exp_elt_opcode (par_state, opcode); + write_exp_string (par_state, token); + write_exp_elt_opcode (par_state, opcode); } /* Emit expression corresponding to the renamed object named @@ -836,7 +862,8 @@ write_exp_op_with_string (enum exp_opcode opcode, struct stoken token) * new encoding entirely (FIXME pnh 7/20/2007). */ static void -write_object_renaming (const struct block *orig_left_context, +write_object_renaming (struct parser_state *par_state, + const struct block *orig_left_context, const char *renamed_entity, int renamed_entity_len, const char *renaming_expr, int max_depth) { @@ -869,10 +896,11 @@ write_object_renaming (const struct block *orig_left_context, &inner_renaming_expr)) { case ADA_NOT_RENAMING: - write_var_from_sym (orig_left_context, sym_info.block, sym_info.sym); + write_var_from_sym (par_state, orig_left_context, sym_info.block, + sym_info.sym); break; case ADA_OBJECT_RENAMING: - write_object_renaming (sym_info.block, + write_object_renaming (par_state, sym_info.block, inner_renamed_entity, inner_renamed_entity_len, inner_renaming_expr, max_depth - 1); break; @@ -889,7 +917,7 @@ write_object_renaming (const struct block *orig_left_context, switch (*renaming_expr) { case 'A': renaming_expr += 1; - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (par_state, UNOP_IND); break; case 'L': slice_state = LOWER_BOUND; @@ -903,10 +931,10 @@ write_object_renaming (const struct block *orig_left_context, if (next == renaming_expr) goto BadEncoding; renaming_expr = next; - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (type_int ()); - write_exp_elt_longcst ((LONGEST) val); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (par_state, OP_LONG); + write_exp_elt_type (par_state, type_int (par_state)); + write_exp_elt_longcst (par_state, (LONGEST) val); + write_exp_elt_opcode (par_state, OP_LONG); } else { @@ -930,20 +958,20 @@ write_object_renaming (const struct block *orig_left_context, else if (SYMBOL_CLASS (index_sym_info.sym) == LOC_TYPEDEF) /* Index is an old-style renaming symbol. */ index_sym_info.block = orig_left_context; - write_var_from_sym (NULL, index_sym_info.block, + write_var_from_sym (par_state, NULL, index_sym_info.block, index_sym_info.sym); } if (slice_state == SIMPLE_INDEX) { - write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ((LONGEST) 1); - write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_opcode (par_state, OP_FUNCALL); + write_exp_elt_longcst (par_state, (LONGEST) 1); + write_exp_elt_opcode (par_state, OP_FUNCALL); } else if (slice_state == LOWER_BOUND) slice_state = UPPER_BOUND; else if (slice_state == UPPER_BOUND) { - write_exp_elt_opcode (TERNOP_SLICE); + write_exp_elt_opcode (par_state, TERNOP_SLICE); slice_state = SIMPLE_INDEX; } break; @@ -967,7 +995,7 @@ write_object_renaming (const struct block *orig_left_context, strncpy (buf, renaming_expr, end - renaming_expr); buf[end - renaming_expr] = '\000'; renaming_expr = end; - write_exp_op_with_string (STRUCTOP_STRUCT, field_name); + write_exp_op_with_string (par_state, STRUCTOP_STRUCT, field_name); break; } @@ -1056,14 +1084,14 @@ select_possible_type_sym (struct ada_symbol_info *syms, int nsyms) } static struct type* -find_primitive_type (char *name) +find_primitive_type (struct parser_state *par_state, char *name) { struct type *type; - type = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, + type = language_lookup_primitive_type_by_name (parse_language (par_state), + parse_gdbarch (par_state), name); if (type == NULL && strcmp ("system__address", name) == 0) - type = type_system_address (); + type = type_system_address (par_state); if (type != NULL) { @@ -1112,7 +1140,7 @@ chop_separator (char *name) is '__' or '.', write the indicated sequence of STRUCTOP_STRUCT expression operators. */ static void -write_selectors (char *sels) +write_selectors (struct parser_state *par_state, char *sels) { while (*sels != '\0') { @@ -1124,7 +1152,7 @@ write_selectors (char *sels) sels += 1; field_name.length = sels - p; field_name.ptr = p; - write_exp_op_with_string (STRUCTOP_STRUCT, field_name); + write_exp_op_with_string (par_state, STRUCTOP_STRUCT, field_name); } } @@ -1133,7 +1161,8 @@ write_selectors (char *sels) a temporary symbol that is valid until the next call to ada_parse. */ static void -write_ambiguous_var (const struct block *block, char *name, int len) +write_ambiguous_var (struct parser_state *par_state, + const struct block *block, char *name, int len) { struct symbol *sym = obstack_alloc (&temp_parse_space, sizeof (struct symbol)); @@ -1142,10 +1171,10 @@ write_ambiguous_var (const struct block *block, char *name, int len) SYMBOL_LINKAGE_NAME (sym) = obstack_copy0 (&temp_parse_space, name, len); SYMBOL_LANGUAGE (sym) = language_ada; - write_exp_elt_opcode (OP_VAR_VALUE); - write_exp_elt_block (block); - write_exp_elt_sym (sym); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (par_state, OP_VAR_VALUE); + write_exp_elt_block (par_state, block); + write_exp_elt_sym (par_state, sym); + write_exp_elt_opcode (par_state, OP_VAR_VALUE); } /* A convenient wrapper around ada_get_field_index that takes @@ -1225,7 +1254,8 @@ get_symbol_field_type (struct symbol *sym, char *encoded_field_name) identifier). */ static struct type* -write_var_or_type (const struct block *block, struct stoken name0) +write_var_or_type (struct parser_state *par_state, + const struct block *block, struct stoken name0) { int depth; char *encoded_name; @@ -1299,9 +1329,9 @@ write_var_or_type (const struct block *block, struct stoken name0) goto TryAfterRenaming; } case ADA_OBJECT_RENAMING: - write_object_renaming (block, renaming, renaming_len, + write_object_renaming (par_state, block, renaming, renaming_len, renaming_expr, MAX_RENAMING_CHAIN_LENGTH); - write_selectors (encoded_name + tail_index); + write_selectors (par_state, encoded_name + tail_index); return NULL; default: internal_error (__FILE__, __LINE__, @@ -1328,7 +1358,8 @@ write_var_or_type (const struct block *block, struct stoken name0) } else if (tail_index == name_len && nsyms == 0) { - struct type *type = find_primitive_type (encoded_name); + struct type *type = find_primitive_type (par_state, + encoded_name); if (type != NULL) return type; @@ -1336,8 +1367,9 @@ write_var_or_type (const struct block *block, struct stoken name0) if (nsyms == 1) { - write_var_from_sym (block, syms[0].block, syms[0].sym); - write_selectors (encoded_name + tail_index); + write_var_from_sym (par_state, block, syms[0].block, + syms[0].sym); + write_selectors (par_state, encoded_name + tail_index); return NULL; } else if (nsyms == 0) @@ -1346,9 +1378,9 @@ write_var_or_type (const struct block *block, struct stoken name0) = ada_lookup_simple_minsym (encoded_name); if (msym.minsym != NULL) { - write_exp_msymbol (msym); + write_exp_msymbol (par_state, msym); /* Maybe cause error here rather than later? FIXME? */ - write_selectors (encoded_name + tail_index); + write_selectors (par_state, encoded_name + tail_index); return NULL; } @@ -1361,8 +1393,9 @@ write_var_or_type (const struct block *block, struct stoken name0) } else { - write_ambiguous_var (block, encoded_name, tail_index); - write_selectors (encoded_name + tail_index); + write_ambiguous_var (par_state, block, encoded_name, + tail_index); + write_selectors (par_state, encoded_name + tail_index); return NULL; } } @@ -1397,7 +1430,7 @@ write_var_or_type (const struct block *block, struct stoken name0) ambiguous name, one must write instead ((R) => 42). */ static void -write_name_assoc (struct stoken name) +write_name_assoc (struct parser_state *par_state, struct stoken name) { if (strchr (name.ptr, '.') == NULL) { @@ -1405,12 +1438,12 @@ write_name_assoc (struct stoken name) int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, VAR_DOMAIN, &syms); if (nsyms != 1 || SYMBOL_CLASS (syms[0].sym) == LOC_TYPEDEF) - write_exp_op_with_string (OP_NAME, name); + write_exp_op_with_string (par_state, OP_NAME, name); else - write_var_from_sym (NULL, syms[0].block, syms[0].sym); + write_var_from_sym (par_state, NULL, syms[0].block, syms[0].sym); } else - if (write_var_or_type (NULL, name) != NULL) + if (write_var_or_type (par_state, NULL, name) != NULL) error (_("Invalid use of type.")); } @@ -1441,61 +1474,62 @@ convert_char_literal (struct type *type, LONGEST val) } static struct type * -type_int (void) +type_int (struct parser_state *par_state) { - return parse_type->builtin_int; + return parse_type (par_state)->builtin_int; } static struct type * -type_long (void) +type_long (struct parser_state *par_state) { - return parse_type->builtin_long; + return parse_type (par_state)->builtin_long; } static struct type * -type_long_long (void) +type_long_long (struct parser_state *par_state) { - return parse_type->builtin_long_long; + return parse_type (par_state)->builtin_long_long; } static struct type * -type_float (void) +type_float (struct parser_state *par_state) { - return parse_type->builtin_float; + return parse_type (par_state)->builtin_float; } static struct type * -type_double (void) +type_double (struct parser_state *par_state) { - return parse_type->builtin_double; + return parse_type (par_state)->builtin_double; } static struct type * -type_long_double (void) +type_long_double (struct parser_state *par_state) { - return parse_type->builtin_long_double; + return parse_type (par_state)->builtin_long_double; } static struct type * -type_char (void) +type_char (struct parser_state *par_state) { - return language_string_char_type (parse_language, parse_gdbarch); + return language_string_char_type (parse_language (par_state), + parse_gdbarch (par_state)); } static struct type * -type_boolean (void) +type_boolean (struct parser_state *par_state) { - return parse_type->builtin_bool; + return parse_type (par_state)->builtin_bool; } static struct type * -type_system_address (void) +type_system_address (struct parser_state *par_state) { struct type *type - = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, + = language_lookup_primitive_type_by_name (parse_language (par_state), + parse_gdbarch (par_state), "system__address"); - return type != NULL ? type : parse_type->builtin_data_ptr; + return type != NULL ? type : parse_type (par_state)->builtin_data_ptr; } /* Provide a prototype to silence -Wmissing-prototypes. */ diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 38df182..71827ae 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -13376,10 +13376,10 @@ emit_char (int c, struct type *type, struct ui_file *stream, int quoter) } static int -parse (void) +parse (struct parser_state *ps) { warnings_issued = 0; - return ada_parse (); + return ada_parse (ps); } static const struct exp_descriptor ada_exp_descriptor = { diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index c053278..6356cfa 100644 --- a/gdb/ada-lang.h +++ b/gdb/ada-lang.h @@ -23,6 +23,7 @@ struct frame_info; struct inferior; struct type_print_options; +struct parser_state; #include "value.h" #include "gdbtypes.h" @@ -169,7 +170,7 @@ extern int ada_get_field_index (const struct type *type, const char *field_name, int maybe_missing); -extern int ada_parse (void); /* Defined in ada-exp.y */ +extern int ada_parse (struct parser_state *); /* Defined in ada-exp.y */ extern void ada_error (char *); /* Defined in ada-exp.y */ diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l index 0787a0f..85c9d88 100644 --- a/gdb/ada-lex.l +++ b/gdb/ada-lex.l @@ -48,8 +48,9 @@ POSEXP (e"+"?{NUM10}) static char numbuf[NUMERAL_WIDTH]; static void canonicalizeNumeral (char *s1, const char *); static struct stoken processString (const char*, int); -static int processInt (const char *, const char *, const char *); -static int processReal (const char *); +static int processInt (struct parser_state *, const char *, const char *, + const char *); +static int processReal (struct parser_state *, const char *); static struct stoken processId (const char *, int); static int processAttribute (const char *); static int find_dot_all (const char *); @@ -89,40 +90,42 @@ static int find_dot_all (const char *); {NUM10}{POSEXP} { canonicalizeNumeral (numbuf, yytext); - return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1); + return processInt (pstate, NULL, numbuf, + strrchr (numbuf, 'e') + 1); } {NUM10} { canonicalizeNumeral (numbuf, yytext); - return processInt (NULL, numbuf, NULL); + return processInt (pstate, NULL, numbuf, NULL); } {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} { canonicalizeNumeral (numbuf, yytext); - return processInt (numbuf, + return processInt (pstate, numbuf, strchr (numbuf, '#') + 1, strrchr(numbuf, '#') + 1); } {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" { canonicalizeNumeral (numbuf, yytext); - return processInt (numbuf, strchr (numbuf, '#') + 1, NULL); + return processInt (pstate, numbuf, strchr (numbuf, '#') + 1, + NULL); } "0x"{HEXDIG}+ { canonicalizeNumeral (numbuf, yytext+2); - return processInt ("16#", numbuf, NULL); + return processInt (pstate, "16#", numbuf, NULL); } {NUM10}"."{NUM10}{EXP} { canonicalizeNumeral (numbuf, yytext); - return processReal (numbuf); + return processReal (pstate, numbuf); } {NUM10}"."{NUM10} { canonicalizeNumeral (numbuf, yytext); - return processReal (numbuf); + return processReal (pstate, numbuf); } {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} { @@ -134,14 +137,14 @@ static int find_dot_all (const char *); } "'"({GRAPHIC}|\")"'" { - yylval.typed_val.type = type_char (); + yylval.typed_val.type = type_char (pstate); yylval.typed_val.val = yytext[1]; return CHARLIT; } "'[\""{HEXDIG}{2}"\"]'" { int v; - yylval.typed_val.type = type_char (); + yylval.typed_val.type = type_char (pstate); sscanf (yytext+3, "%2x", &v); yylval.typed_val.val = v; return CHARLIT; @@ -324,7 +327,8 @@ canonicalizeNumeral (char *s1, const char *s2) */ static int -processInt (const char *base0, const char *num0, const char *exp0) +processInt (struct parser_state *par_state, const char *base0, + const char *num0, const char *exp0) { ULONGEST result; long exp; @@ -360,11 +364,11 @@ processInt (const char *base0, const char *num0, const char *exp0) exp -= 1; } - if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0) - yylval.typed_val.type = type_int (); - else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0) - yylval.typed_val.type = type_long (); - else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0) + if ((result >> (gdbarch_int_bit (parse_gdbarch (par_state))-1)) == 0) + yylval.typed_val.type = type_int (par_state); + else if ((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) == 0) + yylval.typed_val.type = type_long (par_state); + else if (((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) >> 1) == 0) { /* We have a number representable as an unsigned integer quantity. For consistency with the C treatment, we will treat it as an @@ -374,7 +378,7 @@ processInt (const char *base0, const char *num0, const char *exp0) assignment does the trick (no, it doesn't; read the reference manual). */ yylval.typed_val.type - = builtin_type (parse_gdbarch)->builtin_unsigned_long; + = builtin_type (parse_gdbarch (par_state))->builtin_unsigned_long; if (result & LONGEST_SIGN) yylval.typed_val.val = (LONGEST) (result & ~LONGEST_SIGN) @@ -384,24 +388,24 @@ processInt (const char *base0, const char *num0, const char *exp0) return INT; } else - yylval.typed_val.type = type_long_long (); + yylval.typed_val.type = type_long_long (par_state); yylval.typed_val.val = (LONGEST) result; return INT; } static int -processReal (const char *num0) +processReal (struct parser_state *par_state, const char *num0) { sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval); - yylval.typed_val_float.type = type_float (); - if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch) + yylval.typed_val_float.type = type_float (par_state); + if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch (par_state)) / TARGET_CHAR_BIT) - yylval.typed_val_float.type = type_double (); - if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch) + yylval.typed_val_float.type = type_double (par_state); + if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch (par_state)) / TARGET_CHAR_BIT) - yylval.typed_val_float.type = type_long_double (); + yylval.typed_val_float.type = type_long_double (par_state); return FLOAT; }