From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 30169 invoked by alias); 13 Jun 2012 04:57:47 -0000 Received: (qmail 30135 invoked by uid 22791); 13 Jun 2012 04:57:34 -0000 X-SWARE-Spam-Status: No, hits=-3.5 required=5.0 tests=AWL,BAYES_00,KAM_STOCKTIP,KHOP_RCVD_UNTRUST,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,SPF_HELO_PASS,TW_CP,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 13 Jun 2012 04:57:03 +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 q5D4ufLQ008123 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 13 Jun 2012 00:56:41 -0400 Received: from psique (ovpn-113-39.phx2.redhat.com [10.3.113.39]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q5D4ubLk018905; Wed, 13 Jun 2012 00:56:39 -0400 From: Sergio Durigan Junior To: GDB Patches Cc: Tom Tromey , Joel Brobecker Subject: Re: [PATCH 04/10] Ada language. References: <1338665528-5932-1-git-send-email-sergiodj@redhat.com> <1338665528-5932-5-git-send-email-sergiodj@redhat.com> X-URL: http://www.redhat.com Date: Wed, 13 Jun 2012 04:57:00 -0000 In-Reply-To: <1338665528-5932-5-git-send-email-sergiodj@redhat.com> (Sergio Durigan Junior's message of "Sat, 2 Jun 2012 16:32:02 -0300") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-06/txt/msg00379.txt.bz2 On Saturday, June 02 2012, I wrote: > 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. Ping. Joel, I know these changed are rather mechanical, but would you like to take a look and see what you think? Thanks, > > --- > gdb/ada-exp.y | 474 +++++++++++++++++++++++++++++--------------------------- > gdb/ada-lang.c | 4 +- > gdb/ada-lang.h | 3 +- > gdb/ada-lex.l | 54 ++++--- > 4 files changed, 282 insertions(+), 253 deletions(-) > > diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y > index 1a80b0b..3c62187 100644 > --- a/gdb/ada-exp.y > +++ b/gdb/ada-exp.y > @@ -50,7 +50,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 > @@ -114,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 > @@ -128,40 +133,44 @@ void yyerror (char *); > > static struct stoken string_to_operator (struct stoken); > > -static void write_int (LONGEST, struct type *); > +static void write_int (struct parser_state *, LONGEST, struct type *); > > -static void write_object_renaming (struct block *, const char *, int, > +static void write_object_renaming (struct parser_state *, struct block *, > + const char *, int, > const char *, int); > > -static struct type* write_var_or_type (struct block *, struct stoken); > +static struct type* write_var_or_type (struct parser_state *, 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 *, char *); > > static LONGEST convert_char_literal (struct type *, LONGEST); > > -static void write_ambiguous_var (struct block *, char *, int); > +static void write_ambiguous_var (struct parser_state *, 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 *); > > %} > > @@ -237,25 +246,25 @@ 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 ')' > { > @@ -263,15 +272,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); > } > } > ; > @@ -281,9 +290,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; > } > ; > @@ -293,10 +302,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")); > } > @@ -316,15 +325,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 > @@ -334,19 +343,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; } > @@ -367,111 +376,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 > @@ -484,36 +493,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 > @@ -525,36 +534,36 @@ 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 '(' > @@ -568,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 > @@ -622,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 ($$); > } > @@ -653,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 > @@ -673,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; > } > ; > @@ -694,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); > } > ; > > @@ -713,22 +724,22 @@ 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; } > ; > > @@ -736,11 +747,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); } > ; > > %% > @@ -771,8 +782,12 @@ static struct obstack temp_parse_space; > #include "ada-lex.c" > > int > -ada_parse (void) > +ada_parse (struct parser_state *par_state) > { > + /* 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); > @@ -818,7 +833,8 @@ string_to_operator (struct stoken string) > /* 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 (struct block *orig_left_context, > +write_var_from_sym (struct parser_state *par_state, > + struct block *orig_left_context, > struct block *block, > struct symbol *sym) > { > @@ -829,30 +845,31 @@ write_var_from_sym (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 > @@ -867,7 +884,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 (struct block *orig_left_context, > +write_object_renaming (struct parser_state *par_state, > + struct block *orig_left_context, > const char *renamed_entity, int renamed_entity_len, > const char *renaming_expr, int max_depth) > { > @@ -900,10 +918,11 @@ write_object_renaming (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; > @@ -920,7 +939,7 @@ write_object_renaming (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; > @@ -934,10 +953,10 @@ write_object_renaming (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 > { > @@ -961,20 +980,20 @@ write_object_renaming (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; > @@ -995,7 +1014,7 @@ write_object_renaming (struct block *orig_left_context, > strncpy (field_name.ptr, renaming_expr, end - renaming_expr); > field_name.ptr[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; > } > > @@ -1084,14 +1103,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) > { > @@ -1140,7 +1159,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') > { > @@ -1152,7 +1171,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); > } > } > > @@ -1161,7 +1180,8 @@ write_selectors (char *sels) > a temporary symbol that is valid until the next call to ada_parse. > */ > static void > -write_ambiguous_var (struct block *block, char *name, int len) > +write_ambiguous_var (struct parser_state *par_state, struct block *block, > + char *name, int len) > { > struct symbol *sym = > obstack_alloc (&temp_parse_space, sizeof (struct symbol)); > @@ -1170,10 +1190,10 @@ write_ambiguous_var (struct block *block, char *name, int len) > SYMBOL_LINKAGE_NAME (sym) = obsavestring (name, len, &temp_parse_space); > 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 > @@ -1253,7 +1273,8 @@ get_symbol_field_type (struct symbol *sym, char *encoded_field_name) > identifier). */ > > static struct type* > -write_var_or_type (struct block *block, struct stoken name0) > +write_var_or_type (struct parser_state *par_state, struct block *block, > + struct stoken name0) > { > int depth; > char *encoded_name; > @@ -1327,9 +1348,9 @@ write_var_or_type (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__, > @@ -1356,7 +1377,8 @@ write_var_or_type (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; > @@ -1364,8 +1386,9 @@ write_var_or_type (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) > @@ -1374,9 +1397,9 @@ write_var_or_type (struct block *block, struct stoken name0) > = ada_lookup_simple_minsym (encoded_name); > if (msym != 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; > } > > @@ -1389,8 +1412,8 @@ write_var_or_type (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; > } > } > @@ -1425,7 +1448,7 @@ write_var_or_type (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) > { > @@ -1433,12 +1456,12 @@ write_name_assoc (struct stoken name) > int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block, > VAR_DOMAIN, &syms, 1); > 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.")); > } > > @@ -1469,61 +1492,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 af0fdb5..a6308cf 100644 > --- a/gdb/ada-lang.c > +++ b/gdb/ada-lang.c > @@ -12464,10 +12464,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 9a93c50..1b172d4 100644 > --- a/gdb/ada-lang.h > +++ b/gdb/ada-lang.h > @@ -23,6 +23,7 @@ > > struct frame_info; > struct inferior; > +struct parser_state; > > #include "value.h" > #include "gdbtypes.h" > @@ -157,7 +158,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 714265e..f0e2369 100644 > --- a/gdb/ada-lex.l > +++ b/gdb/ada-lex.l > @@ -49,8 +49,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; > @@ -325,7 +328,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; > @@ -362,11 +366,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 > @@ -376,7 +380,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) > @@ -386,24 +390,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; > } > -- > 1.7.7.6 -- Sergio