This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

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


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]