This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [PATCH 04/10] Ada language.
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)
> <sep> 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 *);
> }
>
> <INITIAL>"'"({GRAPHIC}|\")"'" {
> - yylval.typed_val.type = type_char ();
> + yylval.typed_val.type = type_char (pstate);
> yylval.typed_val.val = yytext[1];
> return CHARLIT;
> }
>
> <INITIAL>"'[\""{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