diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index 4273f1d..aa74429 100644
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -49,7 +49,7 @@
 #include "frame.h"
 #include "block.h"
 
-#define parse_type builtin_type (parse_gdbarch)
+#define parse_type(ps) builtin_type (parse_gdbarch (ps))
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
    as well as gratuitiously global symbol names, so we can have multiple
@@ -63,7 +63,8 @@
    without BISON?  (PNH) */
 
 #define	yymaxdepth ada_maxdepth
-#define	yyparse	_ada_parse	/* ada_parse calls this after  initialization */
+/* ada_parse calls this after initialization */
+#define	yyparse	ada_parse_internal
 #define	yylex	ada_lex
 #define	yyerror	ada_error
 #define	yylval	ada_lval
@@ -113,6 +114,11 @@ struct name_info {
   struct stoken stoken;
 };
 
+/* The state of the parser, used internally when we are parsing the
+   expression.  */
+
+static struct parser_state *pstate = NULL;
+
 static struct stoken empty_stoken = { "", 0 };
 
 /* If expression is in the context of TYPE'(...), then TYPE, else
@@ -125,40 +131,44 @@ static int yylex (void);
 
 void yyerror (char *);
 
-static void write_int (LONGEST, struct type *);
+static void write_int (struct parser_state *, LONGEST, struct type *);
 
-static void write_object_renaming (const struct block *, const char *, int,
+static void write_object_renaming (struct parser_state *,
+				   const struct block *, const char *, int,
 				   const char *, int);
 
-static struct type* write_var_or_type (const struct block *, struct stoken);
+static struct type* write_var_or_type (struct parser_state *,
+				       const struct block *, struct stoken);
 
-static void write_name_assoc (struct stoken);
+static void write_name_assoc (struct parser_state *, struct stoken);
 
-static void write_exp_op_with_string (enum exp_opcode, struct stoken);
+static void write_exp_op_with_string (struct parser_state *, enum exp_opcode,
+				      struct stoken);
 
 static struct block *block_lookup (struct block *, const char *);
 
 static LONGEST convert_char_literal (struct type *, LONGEST);
 
-static void write_ambiguous_var (const struct block *, char *, int);
+static void write_ambiguous_var (struct parser_state *,
+				 const struct block *, char *, int);
 
-static struct type *type_int (void);
+static struct type *type_int (struct parser_state *);
 
-static struct type *type_long (void);
+static struct type *type_long (struct parser_state *);
 
-static struct type *type_long_long (void);
+static struct type *type_long_long (struct parser_state *);
 
-static struct type *type_float (void);
+static struct type *type_float (struct parser_state *);
 
-static struct type *type_double (void);
+static struct type *type_double (struct parser_state *);
 
-static struct type *type_long_double (void);
+static struct type *type_long_double (struct parser_state *);
 
-static struct type *type_char (void);
+static struct type *type_char (struct parser_state *);
 
-static struct type *type_boolean (void);
+static struct type *type_boolean (struct parser_state *);
 
-static struct type *type_system_address (void);
+static struct type *type_system_address (struct parser_state *);
 
 %}
 
@@ -234,25 +244,26 @@ start   :	exp1
 /* Expressions, including the sequencing operator.  */
 exp1	:	exp
 	|	exp1 ';' exp
-			{ write_exp_elt_opcode (BINOP_COMMA); }
+			{ write_exp_elt_opcode (pstate, BINOP_COMMA); }
 	| 	primary ASSIGN exp   /* Extension for convenience */
-			{ write_exp_elt_opcode (BINOP_ASSIGN); }
+			{ write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
 	;
 
 /* Expressions, not including the sequencing operator.  */
 primary :	primary DOT_ALL
-			{ write_exp_elt_opcode (UNOP_IND); }
+			{ write_exp_elt_opcode (pstate, UNOP_IND); }
 	;
 
 primary :	primary DOT_ID
-			{ write_exp_op_with_string (STRUCTOP_STRUCT, $2); }
+			{ write_exp_op_with_string (pstate, STRUCTOP_STRUCT,
+						    $2); }
 	;
 
 primary :	primary '(' arglist ')'
 			{
-			  write_exp_elt_opcode (OP_FUNCALL);
-			  write_exp_elt_longcst ($3);
-			  write_exp_elt_opcode (OP_FUNCALL);
+			  write_exp_elt_opcode (pstate, OP_FUNCALL);
+			  write_exp_elt_longcst (pstate, $3);
+			  write_exp_elt_opcode (pstate, OP_FUNCALL);
 		        }
 	|	var_or_type '(' arglist ')'
 			{
@@ -260,15 +271,15 @@ primary :	primary '(' arglist ')'
 			    {
 			      if ($3 != 1)
 				error (_("Invalid conversion"));
-			      write_exp_elt_opcode (UNOP_CAST);
-			      write_exp_elt_type ($1);
-			      write_exp_elt_opcode (UNOP_CAST);
+			      write_exp_elt_opcode (pstate, UNOP_CAST);
+			      write_exp_elt_type (pstate, $1);
+			      write_exp_elt_opcode (pstate, UNOP_CAST);
 			    }
 			  else
 			    {
-			      write_exp_elt_opcode (OP_FUNCALL);
-			      write_exp_elt_longcst ($3);
-			      write_exp_elt_opcode (OP_FUNCALL);
+			      write_exp_elt_opcode (pstate, OP_FUNCALL);
+			      write_exp_elt_longcst (pstate, $3);
+			      write_exp_elt_opcode (pstate, OP_FUNCALL);
 			    }
 			}
 	;
@@ -278,9 +289,9 @@ primary :	var_or_type '\'' save_qualifier { type_qualifier = $1; }
 			{
 			  if ($1 == NULL)
 			    error (_("Type required for qualification"));
-			  write_exp_elt_opcode (UNOP_QUAL);
-			  write_exp_elt_type ($1);
-			  write_exp_elt_opcode (UNOP_QUAL);
+			  write_exp_elt_opcode (pstate, UNOP_QUAL);
+			  write_exp_elt_type (pstate, $1);
+			  write_exp_elt_opcode (pstate, UNOP_QUAL);
 			  type_qualifier = $3;
 			}
 	;
@@ -290,10 +301,10 @@ save_qualifier : 	{ $$ = type_qualifier; }
 
 primary :
 		primary '(' simple_exp DOTDOT simple_exp ')'
-			{ write_exp_elt_opcode (TERNOP_SLICE); }
+			{ write_exp_elt_opcode (pstate, TERNOP_SLICE); }
 	|	var_or_type '(' simple_exp DOTDOT simple_exp ')'
 			{ if ($1 == NULL) 
-                            write_exp_elt_opcode (TERNOP_SLICE);
+                            write_exp_elt_opcode (pstate, TERNOP_SLICE);
 			  else
 			    error (_("Cannot slice a type"));
 			}
@@ -313,15 +324,15 @@ primary :	'(' exp1 ')'	{ }
 primary :	var_or_type	%prec VAR
 			{ if ($1 != NULL)
 			    {
-			      write_exp_elt_opcode (OP_TYPE);
-			      write_exp_elt_type ($1);
-			      write_exp_elt_opcode (OP_TYPE);
+			      write_exp_elt_opcode (pstate, OP_TYPE);
+			      write_exp_elt_type (pstate, $1);
+			      write_exp_elt_opcode (pstate, OP_TYPE);
 			    }
 			}
 	;
 
 primary :	SPECIAL_VARIABLE /* Various GDB extensions */
-			{ write_dollar_variable ($1); }
+			{ write_dollar_variable (pstate, $1); }
 	;
 
 primary :     	aggregate
@@ -331,19 +342,19 @@ simple_exp : 	primary
 	;
 
 simple_exp :	'-' simple_exp    %prec UNARY
-			{ write_exp_elt_opcode (UNOP_NEG); }
+			{ write_exp_elt_opcode (pstate, UNOP_NEG); }
 	;
 
 simple_exp :	'+' simple_exp    %prec UNARY
-			{ write_exp_elt_opcode (UNOP_PLUS); }
+			{ write_exp_elt_opcode (pstate, UNOP_PLUS); }
 	;
 
 simple_exp :	NOT simple_exp    %prec UNARY
-			{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
+			{ write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
 	;
 
 simple_exp :    ABS simple_exp	   %prec UNARY
-			{ write_exp_elt_opcode (UNOP_ABS); }
+			{ write_exp_elt_opcode (pstate, UNOP_ABS); }
 	;
 
 arglist	:		{ $$ = 0; }
@@ -364,111 +375,111 @@ primary :	'{' var_or_type '}' primary  %prec '.'
 			{ 
 			  if ($2 == NULL)
 			    error (_("Type required within braces in coercion"));
-			  write_exp_elt_opcode (UNOP_MEMVAL);
-			  write_exp_elt_type ($2);
-			  write_exp_elt_opcode (UNOP_MEMVAL);
+			  write_exp_elt_opcode (pstate, UNOP_MEMVAL);
+			  write_exp_elt_type (pstate, $2);
+			  write_exp_elt_opcode (pstate, UNOP_MEMVAL);
 			}
 	;
 
 /* Binary operators in order of decreasing precedence.  */
 
 simple_exp 	: 	simple_exp STARSTAR simple_exp
-			{ write_exp_elt_opcode (BINOP_EXP); }
+			{ write_exp_elt_opcode (pstate, BINOP_EXP); }
 	;
 
 simple_exp	:	simple_exp '*' simple_exp
-			{ write_exp_elt_opcode (BINOP_MUL); }
+			{ write_exp_elt_opcode (pstate, BINOP_MUL); }
 	;
 
 simple_exp	:	simple_exp '/' simple_exp
-			{ write_exp_elt_opcode (BINOP_DIV); }
+			{ write_exp_elt_opcode (pstate, BINOP_DIV); }
 	;
 
 simple_exp	:	simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */
-			{ write_exp_elt_opcode (BINOP_REM); }
+			{ write_exp_elt_opcode (pstate, BINOP_REM); }
 	;
 
 simple_exp	:	simple_exp MOD simple_exp
-			{ write_exp_elt_opcode (BINOP_MOD); }
+			{ write_exp_elt_opcode (pstate, BINOP_MOD); }
 	;
 
 simple_exp	:	simple_exp '@' simple_exp	/* GDB extension */
-			{ write_exp_elt_opcode (BINOP_REPEAT); }
+			{ write_exp_elt_opcode (pstate, BINOP_REPEAT); }
 	;
 
 simple_exp	:	simple_exp '+' simple_exp
-			{ write_exp_elt_opcode (BINOP_ADD); }
+			{ write_exp_elt_opcode (pstate, BINOP_ADD); }
 	;
 
 simple_exp	:	simple_exp '&' simple_exp
-			{ write_exp_elt_opcode (BINOP_CONCAT); }
+			{ write_exp_elt_opcode (pstate, BINOP_CONCAT); }
 	;
 
 simple_exp	:	simple_exp '-' simple_exp
-			{ write_exp_elt_opcode (BINOP_SUB); }
+			{ write_exp_elt_opcode (pstate, BINOP_SUB); }
 	;
 
 relation :	simple_exp
 	;
 
 relation :	simple_exp '=' simple_exp
-			{ write_exp_elt_opcode (BINOP_EQUAL); }
+			{ write_exp_elt_opcode (pstate, BINOP_EQUAL); }
 	;
 
 relation :	simple_exp NOTEQUAL simple_exp
-			{ write_exp_elt_opcode (BINOP_NOTEQUAL); }
+			{ write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
 	;
 
 relation :	simple_exp LEQ simple_exp
-			{ write_exp_elt_opcode (BINOP_LEQ); }
+			{ write_exp_elt_opcode (pstate, BINOP_LEQ); }
 	;
 
 relation :	simple_exp IN simple_exp DOTDOT simple_exp
-			{ write_exp_elt_opcode (TERNOP_IN_RANGE); }
+			{ write_exp_elt_opcode (pstate, TERNOP_IN_RANGE); }
         |       simple_exp IN primary TICK_RANGE tick_arglist
-			{ write_exp_elt_opcode (BINOP_IN_BOUNDS);
-			  write_exp_elt_longcst ((LONGEST) $5);
-			  write_exp_elt_opcode (BINOP_IN_BOUNDS);
+			{ write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS);
+			  write_exp_elt_longcst (pstate, (LONGEST) $5);
+			  write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS);
 			}
  	|	simple_exp IN var_or_type	%prec TICK_ACCESS
 			{ 
 			  if ($3 == NULL)
 			    error (_("Right operand of 'in' must be type"));
-			  write_exp_elt_opcode (UNOP_IN_RANGE);
-		          write_exp_elt_type ($3);
-		          write_exp_elt_opcode (UNOP_IN_RANGE);
+			  write_exp_elt_opcode (pstate, UNOP_IN_RANGE);
+		          write_exp_elt_type (pstate, $3);
+		          write_exp_elt_opcode (pstate, UNOP_IN_RANGE);
 			}
 	|	simple_exp NOT IN simple_exp DOTDOT simple_exp
-			{ write_exp_elt_opcode (TERNOP_IN_RANGE);
-		          write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+			{ write_exp_elt_opcode (pstate, TERNOP_IN_RANGE);
+		          write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT);
 			}
         |       simple_exp NOT IN primary TICK_RANGE tick_arglist
-			{ write_exp_elt_opcode (BINOP_IN_BOUNDS);
-			  write_exp_elt_longcst ((LONGEST) $6);
-			  write_exp_elt_opcode (BINOP_IN_BOUNDS);
-		          write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+			{ write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS);
+			  write_exp_elt_longcst (pstate, (LONGEST) $6);
+			  write_exp_elt_opcode (pstate, BINOP_IN_BOUNDS);
+		          write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT);
 			}
  	|	simple_exp NOT IN var_or_type	%prec TICK_ACCESS
 			{ 
 			  if ($4 == NULL)
 			    error (_("Right operand of 'in' must be type"));
-			  write_exp_elt_opcode (UNOP_IN_RANGE);
-		          write_exp_elt_type ($4);
-		          write_exp_elt_opcode (UNOP_IN_RANGE);
-		          write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+			  write_exp_elt_opcode (pstate, UNOP_IN_RANGE);
+		          write_exp_elt_type (pstate, $4);
+		          write_exp_elt_opcode (pstate, UNOP_IN_RANGE);
+		          write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT);
 			}
 	;
 
 relation :	simple_exp GEQ simple_exp
-			{ write_exp_elt_opcode (BINOP_GEQ); }
+			{ write_exp_elt_opcode (pstate, BINOP_GEQ); }
 	;
 
 relation :	simple_exp '<' simple_exp
-			{ write_exp_elt_opcode (BINOP_LESS); }
+			{ write_exp_elt_opcode (pstate, BINOP_LESS); }
 	;
 
 relation :	simple_exp '>' simple_exp
-			{ write_exp_elt_opcode (BINOP_GTR); }
+			{ write_exp_elt_opcode (pstate, BINOP_GTR); }
 	;
 
 exp	:	relation
@@ -481,36 +492,36 @@ exp	:	relation
 
 and_exp :
 		relation _AND_ relation 
-			{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
 	|	and_exp _AND_ relation
-			{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
 	;
 
 and_then_exp :
 	       relation _AND_ THEN relation
-			{ write_exp_elt_opcode (BINOP_LOGICAL_AND); }
+			{ write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
 	|	and_then_exp _AND_ THEN relation
-			{ write_exp_elt_opcode (BINOP_LOGICAL_AND); }
+			{ write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
         ;
 
 or_exp :
 		relation OR relation 
-			{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
 	|	or_exp OR relation
-			{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
 	;
 
 or_else_exp :
 	       relation OR ELSE relation
-			{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
+			{ write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
 	|      or_else_exp OR ELSE relation
-			{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
+			{ write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
         ;
 
 xor_exp :       relation XOR relation
-			{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
 	|	xor_exp XOR relation
-			{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
+			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
         ;
 
 /* Primaries can denote types (OP_TYPE).  In cases such as 
@@ -522,36 +533,37 @@ xor_exp :       relation XOR relation
    aType'access evaluates to a type that evaluate_subexp attempts to 
    evaluate. */
 primary :	primary TICK_ACCESS
-			{ write_exp_elt_opcode (UNOP_ADDR); }
+			{ write_exp_elt_opcode (pstate, UNOP_ADDR); }
 	|	primary TICK_ADDRESS
-			{ write_exp_elt_opcode (UNOP_ADDR);
-			  write_exp_elt_opcode (UNOP_CAST);
-			  write_exp_elt_type (type_system_address ());
-			  write_exp_elt_opcode (UNOP_CAST);
+			{ write_exp_elt_opcode (pstate, UNOP_ADDR);
+			  write_exp_elt_opcode (pstate, UNOP_CAST);
+			  write_exp_elt_type (pstate,
+					      type_system_address (pstate));
+			  write_exp_elt_opcode (pstate, UNOP_CAST);
 			}
 	|	primary TICK_FIRST tick_arglist
-			{ write_int ($3, type_int ());
-			  write_exp_elt_opcode (OP_ATR_FIRST); }
+			{ write_int (pstate, $3, type_int (pstate));
+			  write_exp_elt_opcode (pstate, OP_ATR_FIRST); }
 	|	primary TICK_LAST tick_arglist
-			{ write_int ($3, type_int ());
-			  write_exp_elt_opcode (OP_ATR_LAST); }
+			{ write_int (pstate, $3, type_int (pstate));
+			  write_exp_elt_opcode (pstate, OP_ATR_LAST); }
 	| 	primary TICK_LENGTH tick_arglist
-			{ write_int ($3, type_int ());
-			  write_exp_elt_opcode (OP_ATR_LENGTH); }
+			{ write_int (pstate, $3, type_int (pstate));
+			  write_exp_elt_opcode (pstate, OP_ATR_LENGTH); }
         |       primary TICK_SIZE
-			{ write_exp_elt_opcode (OP_ATR_SIZE); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_SIZE); }
 	|	primary TICK_TAG
-			{ write_exp_elt_opcode (OP_ATR_TAG); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_TAG); }
         |       opt_type_prefix TICK_MIN '(' exp ',' exp ')'
-			{ write_exp_elt_opcode (OP_ATR_MIN); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_MIN); }
         |       opt_type_prefix TICK_MAX '(' exp ',' exp ')'
-			{ write_exp_elt_opcode (OP_ATR_MAX); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_MAX); }
 	| 	opt_type_prefix TICK_POS '(' exp ')'
-			{ write_exp_elt_opcode (OP_ATR_POS); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_POS); }
 	|	type_prefix TICK_VAL '(' exp ')'
-			{ write_exp_elt_opcode (OP_ATR_VAL); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_VAL); }
 	|	type_prefix TICK_MODULUS
-			{ write_exp_elt_opcode (OP_ATR_MODULUS); }
+			{ write_exp_elt_opcode (pstate, OP_ATR_MODULUS); }
 	;
 
 tick_arglist :			%prec '('
@@ -565,53 +577,55 @@ type_prefix :
 			{ 
 			  if ($1 == NULL)
 			    error (_("Prefix must be type"));
-			  write_exp_elt_opcode (OP_TYPE);
-			  write_exp_elt_type ($1);
-			  write_exp_elt_opcode (OP_TYPE); }
+			  write_exp_elt_opcode (pstate, OP_TYPE);
+			  write_exp_elt_type (pstate, $1);
+			  write_exp_elt_opcode (pstate, OP_TYPE); }
 	;
 
 opt_type_prefix :
 		type_prefix
 	| 	/* EMPTY */
-			{ write_exp_elt_opcode (OP_TYPE);
-			  write_exp_elt_type (parse_type->builtin_void);
-			  write_exp_elt_opcode (OP_TYPE); }
+			{ write_exp_elt_opcode (pstate, OP_TYPE);
+			  write_exp_elt_type (pstate,
+					  parse_type (pstate)->builtin_void);
+			  write_exp_elt_opcode (pstate, OP_TYPE); }
 	;
 
 
 primary	:	INT
-			{ write_int ((LONGEST) $1.val, $1.type); }
+			{ write_int (pstate, (LONGEST) $1.val, $1.type); }
 	;
 
 primary	:	CHARLIT
-                  { write_int (convert_char_literal (type_qualifier, $1.val),
+                  { write_int (pstate,
+			       convert_char_literal (type_qualifier, $1.val),
 			       (type_qualifier == NULL) 
 			       ? $1.type : type_qualifier);
 		  }
 	;
 
 primary	:	FLOAT
-			{ write_exp_elt_opcode (OP_DOUBLE);
-			  write_exp_elt_type ($1.type);
-			  write_exp_elt_dblcst ($1.dval);
-			  write_exp_elt_opcode (OP_DOUBLE);
+			{ write_exp_elt_opcode (pstate, OP_DOUBLE);
+			  write_exp_elt_type (pstate, $1.type);
+			  write_exp_elt_dblcst (pstate, $1.dval);
+			  write_exp_elt_opcode (pstate, OP_DOUBLE);
 			}
 	;
 
 primary	:	NULL_PTR
-			{ write_int (0, type_int ()); }
+			{ write_int (pstate, 0, type_int (pstate)); }
 	;
 
 primary	:	STRING
 			{ 
-			  write_exp_op_with_string (OP_STRING, $1);
+			  write_exp_op_with_string (pstate, OP_STRING, $1);
 			}
 	;
 
 primary :	TRUEKEYWORD
-			{ write_int (1, type_boolean ()); }
+			{ write_int (pstate, 1, type_boolean (pstate)); }
         |	FALSEKEYWORD
-			{ write_int (0, type_boolean ()); }
+			{ write_int (pstate, 0, type_boolean (pstate)); }
 	;
 
 primary	: 	NEW NAME
@@ -619,22 +633,22 @@ primary	: 	NEW NAME
 	;
 
 var_or_type:	NAME   	    %prec VAR
-				{ $$ = write_var_or_type (NULL, $1); } 
+				{ $$ = write_var_or_type (pstate, NULL, $1); }
 	|	block NAME  %prec VAR
-                                { $$ = write_var_or_type ($1, $2); }
+                                { $$ = write_var_or_type (pstate, $1, $2); }
 	|       NAME TICK_ACCESS 
 			{ 
-			  $$ = write_var_or_type (NULL, $1);
+			  $$ = write_var_or_type (pstate, NULL, $1);
 			  if ($$ == NULL)
-			    write_exp_elt_opcode (UNOP_ADDR);
+			    write_exp_elt_opcode (pstate, UNOP_ADDR);
 			  else
 			    $$ = lookup_pointer_type ($$);
 			}
 	|	block NAME TICK_ACCESS
 			{ 
-			  $$ = write_var_or_type ($1, $2);
+			  $$ = write_var_or_type (pstate, $1, $2);
 			  if ($$ == NULL)
-			    write_exp_elt_opcode (UNOP_ADDR);
+			    write_exp_elt_opcode (pstate, UNOP_ADDR);
 			  else
 			    $$ = lookup_pointer_type ($$);
 			}
@@ -650,18 +664,18 @@ block   :       NAME COLONCOLON
 aggregate :
 		'(' aggregate_component_list ')'  
 			{
-			  write_exp_elt_opcode (OP_AGGREGATE);
-			  write_exp_elt_longcst ($2);
-			  write_exp_elt_opcode (OP_AGGREGATE);
+			  write_exp_elt_opcode (pstate, OP_AGGREGATE);
+			  write_exp_elt_longcst (pstate, $2);
+			  write_exp_elt_opcode (pstate, OP_AGGREGATE);
 		        }
 	;
 
 aggregate_component_list :
 		component_groups	 { $$ = $1; }
 	|	positional_list exp
-			{ write_exp_elt_opcode (OP_POSITIONAL);
-			  write_exp_elt_longcst ($1);
-			  write_exp_elt_opcode (OP_POSITIONAL);
+			{ write_exp_elt_opcode (pstate, OP_POSITIONAL);
+			  write_exp_elt_longcst (pstate, $1);
+			  write_exp_elt_opcode (pstate, OP_POSITIONAL);
 			  $$ = $1 + 1;
 			}
 	|	positional_list component_groups
@@ -670,15 +684,15 @@ aggregate_component_list :
 
 positional_list :
 		exp ','
-			{ write_exp_elt_opcode (OP_POSITIONAL);
-			  write_exp_elt_longcst (0);
-			  write_exp_elt_opcode (OP_POSITIONAL);
+			{ write_exp_elt_opcode (pstate, OP_POSITIONAL);
+			  write_exp_elt_longcst (pstate, 0);
+			  write_exp_elt_opcode (pstate, OP_POSITIONAL);
 			  $$ = 1;
 			} 
 	|	positional_list exp ','
-			{ write_exp_elt_opcode (OP_POSITIONAL);
-			  write_exp_elt_longcst ($1);
-			  write_exp_elt_opcode (OP_POSITIONAL);
+			{ write_exp_elt_opcode (pstate, OP_POSITIONAL);
+			  write_exp_elt_longcst (pstate, $1);
+			  write_exp_elt_opcode (pstate, OP_POSITIONAL);
 			  $$ = $1 + 1; 
 			}
 	;
@@ -691,15 +705,15 @@ component_groups:
 	;
 
 others 	:	OTHERS ARROW exp
-			{ write_exp_elt_opcode (OP_OTHERS); }
+			{ write_exp_elt_opcode (pstate, OP_OTHERS); }
 	;
 
 component_group :
 		component_associations
 			{
-			  write_exp_elt_opcode (OP_CHOICES);
-			  write_exp_elt_longcst ($1);
-			  write_exp_elt_opcode (OP_CHOICES);
+			  write_exp_elt_opcode (pstate, OP_CHOICES);
+			  write_exp_elt_longcst (pstate, $1);
+			  write_exp_elt_opcode (pstate, OP_CHOICES);
 		        }
 	;
 
@@ -710,22 +724,23 @@ component_group :
    resolved shift/reduce conflict. */
 component_associations :
 		NAME ARROW 
-			{ write_name_assoc ($1); }
+			{ write_name_assoc (pstate, $1); }
 		    exp	{ $$ = 1; }
 	|	simple_exp ARROW exp
 			{ $$ = 1; }
 	|	simple_exp DOTDOT simple_exp ARROW 
-			{ write_exp_elt_opcode (OP_DISCRETE_RANGE);
-			  write_exp_op_with_string (OP_NAME, empty_stoken);
+			{ write_exp_elt_opcode (pstate, OP_DISCRETE_RANGE);
+			  write_exp_op_with_string (pstate, OP_NAME,
+						    empty_stoken);
 			}
 		    exp { $$ = 1; }
 	|	NAME '|' 
-		        { write_name_assoc ($1); }
+		        { write_name_assoc (pstate, $1); }
 		    component_associations  { $$ = $4 + 1; }
 	|	simple_exp '|'  
 	            component_associations  { $$ = $3 + 1; }
 	|	simple_exp DOTDOT simple_exp '|'
-			{ write_exp_elt_opcode (OP_DISCRETE_RANGE); }
+			{ write_exp_elt_opcode (pstate, OP_DISCRETE_RANGE); }
 		    component_associations  { $$ = $6 + 1; }
 	;
 
@@ -733,11 +748,11 @@ component_associations :
    can't get used to Ada notation in GDB.  */
 
 primary	:	'*' primary		%prec '.'
-			{ write_exp_elt_opcode (UNOP_IND); }
+			{ write_exp_elt_opcode (pstate, UNOP_IND); }
 	|	'&' primary		%prec '.'
-			{ write_exp_elt_opcode (UNOP_ADDR); }
+			{ write_exp_elt_opcode (pstate, UNOP_ADDR); }
 	|	primary '[' exp ']'
-			{ write_exp_elt_opcode (BINOP_SUBSCRIPT); }
+			{ write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
 	;
 
 %%
@@ -768,14 +783,23 @@ static struct obstack temp_parse_space;
 #include "ada-lex.c"
 
 int
-ada_parse (void)
+ada_parse (struct parser_state *par_state)
 {
+  int result;
+  struct cleanup *c = make_cleanup_clear_parser_state (&pstate);
+
+  /* Setting up the parser state.  */
+  gdb_assert (par_state != NULL);
+  pstate = par_state;
+
   lexer_init (yyin);		/* (Re-)initialize lexer.  */
   type_qualifier = NULL;
   obstack_free (&temp_parse_space, NULL);
   obstack_init (&temp_parse_space);
 
-  return _ada_parse ();
+  result = yyparse ();
+  do_cleanups (c);
+  return result;
 }
 
 void
@@ -787,7 +811,8 @@ yyerror (char *msg)
 /* Emit expression to access an instance of SYM, in block BLOCK (if
  * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT.  */
 static void
-write_var_from_sym (const struct block *orig_left_context,
+write_var_from_sym (struct parser_state *par_state,
+		    const struct block *orig_left_context,
 		    const struct block *block,
 		    struct symbol *sym)
 {
@@ -798,30 +823,31 @@ write_var_from_sym (const struct block *orig_left_context,
 	innermost_block = block;
     }
 
-  write_exp_elt_opcode (OP_VAR_VALUE);
-  write_exp_elt_block (block);
-  write_exp_elt_sym (sym);
-  write_exp_elt_opcode (OP_VAR_VALUE);
+  write_exp_elt_opcode (par_state, OP_VAR_VALUE);
+  write_exp_elt_block (par_state, block);
+  write_exp_elt_sym (par_state, sym);
+  write_exp_elt_opcode (par_state, OP_VAR_VALUE);
 }
 
 /* Write integer or boolean constant ARG of type TYPE.  */
 
 static void
-write_int (LONGEST arg, struct type *type)
+write_int (struct parser_state *par_state, LONGEST arg, struct type *type)
 {
-  write_exp_elt_opcode (OP_LONG);
-  write_exp_elt_type (type);
-  write_exp_elt_longcst (arg);
-  write_exp_elt_opcode (OP_LONG);
+  write_exp_elt_opcode (par_state, OP_LONG);
+  write_exp_elt_type (par_state, type);
+  write_exp_elt_longcst (par_state, arg);
+  write_exp_elt_opcode (par_state, OP_LONG);
 }
 
 /* Write an OPCODE, string, OPCODE sequence to the current expression.  */
 static void
-write_exp_op_with_string (enum exp_opcode opcode, struct stoken token)
+write_exp_op_with_string (struct parser_state *par_state,
+			  enum exp_opcode opcode, struct stoken token)
 {
-  write_exp_elt_opcode (opcode);
-  write_exp_string (token);
-  write_exp_elt_opcode (opcode);
+  write_exp_elt_opcode (par_state, opcode);
+  write_exp_string (par_state, token);
+  write_exp_elt_opcode (par_state, opcode);
 }
   
 /* Emit expression corresponding to the renamed object named 
@@ -836,7 +862,8 @@ write_exp_op_with_string (enum exp_opcode opcode, struct stoken token)
  * new encoding entirely (FIXME pnh 7/20/2007).  */
 
 static void
-write_object_renaming (const struct block *orig_left_context,
+write_object_renaming (struct parser_state *par_state,
+		       const struct block *orig_left_context,
 		       const char *renamed_entity, int renamed_entity_len,
 		       const char *renaming_expr, int max_depth)
 {
@@ -869,10 +896,11 @@ write_object_renaming (const struct block *orig_left_context,
 				&inner_renaming_expr))
       {
       case ADA_NOT_RENAMING:
-	write_var_from_sym (orig_left_context, sym_info.block, sym_info.sym);
+	write_var_from_sym (par_state, orig_left_context, sym_info.block,
+			    sym_info.sym);
 	break;
       case ADA_OBJECT_RENAMING:
-	write_object_renaming (sym_info.block,
+	write_object_renaming (par_state, sym_info.block,
 			       inner_renamed_entity, inner_renamed_entity_len,
 			       inner_renaming_expr, max_depth - 1);
 	break;
@@ -889,7 +917,7 @@ write_object_renaming (const struct block *orig_left_context,
       switch (*renaming_expr) {
       case 'A':
         renaming_expr += 1;
-        write_exp_elt_opcode (UNOP_IND);
+        write_exp_elt_opcode (par_state, UNOP_IND);
         break;
       case 'L':
 	slice_state = LOWER_BOUND;
@@ -903,10 +931,10 @@ write_object_renaming (const struct block *orig_left_context,
 	    if (next == renaming_expr)
 	      goto BadEncoding;
 	    renaming_expr = next;
-	    write_exp_elt_opcode (OP_LONG);
-	    write_exp_elt_type (type_int ());
-	    write_exp_elt_longcst ((LONGEST) val);
-	    write_exp_elt_opcode (OP_LONG);
+	    write_exp_elt_opcode (par_state, OP_LONG);
+	    write_exp_elt_type (par_state, type_int (par_state));
+	    write_exp_elt_longcst (par_state, (LONGEST) val);
+	    write_exp_elt_opcode (par_state, OP_LONG);
 	  }
 	else
 	  {
@@ -930,20 +958,20 @@ write_object_renaming (const struct block *orig_left_context,
 	    else if (SYMBOL_CLASS (index_sym_info.sym) == LOC_TYPEDEF)
 	      /* Index is an old-style renaming symbol.  */
 	      index_sym_info.block = orig_left_context;
-	    write_var_from_sym (NULL, index_sym_info.block,
+	    write_var_from_sym (par_state, NULL, index_sym_info.block,
 				index_sym_info.sym);
 	  }
 	if (slice_state == SIMPLE_INDEX)
 	  {
-	    write_exp_elt_opcode (OP_FUNCALL);
-	    write_exp_elt_longcst ((LONGEST) 1);
-	    write_exp_elt_opcode (OP_FUNCALL);
+	    write_exp_elt_opcode (par_state, OP_FUNCALL);
+	    write_exp_elt_longcst (par_state, (LONGEST) 1);
+	    write_exp_elt_opcode (par_state, OP_FUNCALL);
 	  }
 	else if (slice_state == LOWER_BOUND)
 	  slice_state = UPPER_BOUND;
 	else if (slice_state == UPPER_BOUND)
 	  {
-	    write_exp_elt_opcode (TERNOP_SLICE);
+	    write_exp_elt_opcode (par_state, TERNOP_SLICE);
 	    slice_state = SIMPLE_INDEX;
 	  }
 	break;
@@ -967,7 +995,7 @@ write_object_renaming (const struct block *orig_left_context,
 	  strncpy (buf, renaming_expr, end - renaming_expr);
 	  buf[end - renaming_expr] = '\000';
 	  renaming_expr = end;
-	  write_exp_op_with_string (STRUCTOP_STRUCT, field_name);
+	  write_exp_op_with_string (par_state, STRUCTOP_STRUCT, field_name);
 	  break;
 	}
 
@@ -1056,14 +1084,14 @@ select_possible_type_sym (struct ada_symbol_info *syms, int nsyms)
 }
 
 static struct type*
-find_primitive_type (char *name)
+find_primitive_type (struct parser_state *par_state, char *name)
 {
   struct type *type;
-  type = language_lookup_primitive_type_by_name (parse_language,
-						 parse_gdbarch,
+  type = language_lookup_primitive_type_by_name (parse_language (par_state),
+						 parse_gdbarch (par_state),
 						 name);
   if (type == NULL && strcmp ("system__address", name) == 0)
-    type = type_system_address ();
+    type = type_system_address (par_state);
 
   if (type != NULL)
     {
@@ -1112,7 +1140,7 @@ chop_separator (char *name)
    <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')
     {
@@ -1124,7 +1152,7 @@ write_selectors (char *sels)
 	sels += 1;
       field_name.length = sels - p;
       field_name.ptr = p;
-      write_exp_op_with_string (STRUCTOP_STRUCT, field_name);
+      write_exp_op_with_string (par_state, STRUCTOP_STRUCT, field_name);
     }
 }
 
@@ -1133,7 +1161,8 @@ write_selectors (char *sels)
    a temporary symbol that is valid until the next call to ada_parse.
    */
 static void
-write_ambiguous_var (const struct block *block, char *name, int len)
+write_ambiguous_var (struct parser_state *par_state,
+		     const struct block *block, char *name, int len)
 {
   struct symbol *sym =
     obstack_alloc (&temp_parse_space, sizeof (struct symbol));
@@ -1142,10 +1171,10 @@ write_ambiguous_var (const struct block *block, char *name, int len)
   SYMBOL_LINKAGE_NAME (sym) = obstack_copy0 (&temp_parse_space, name, len);
   SYMBOL_LANGUAGE (sym) = language_ada;
 
-  write_exp_elt_opcode (OP_VAR_VALUE);
-  write_exp_elt_block (block);
-  write_exp_elt_sym (sym);
-  write_exp_elt_opcode (OP_VAR_VALUE);
+  write_exp_elt_opcode (par_state, OP_VAR_VALUE);
+  write_exp_elt_block (par_state, block);
+  write_exp_elt_sym (par_state, sym);
+  write_exp_elt_opcode (par_state, OP_VAR_VALUE);
 }
 
 /* A convenient wrapper around ada_get_field_index that takes
@@ -1225,7 +1254,8 @@ get_symbol_field_type (struct symbol *sym, char *encoded_field_name)
    identifier).  */
 
 static struct type*
-write_var_or_type (const struct block *block, struct stoken name0)
+write_var_or_type (struct parser_state *par_state,
+		   const struct block *block, struct stoken name0)
 {
   int depth;
   char *encoded_name;
@@ -1299,9 +1329,9 @@ write_var_or_type (const struct block *block, struct stoken name0)
 		goto TryAfterRenaming;
 	      }	
 	    case ADA_OBJECT_RENAMING:
-	      write_object_renaming (block, renaming, renaming_len, 
+	      write_object_renaming (par_state, block, renaming, renaming_len,
 				     renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
-	      write_selectors (encoded_name + tail_index);
+	      write_selectors (par_state, encoded_name + tail_index);
 	      return NULL;
 	    default:
 	      internal_error (__FILE__, __LINE__,
@@ -1328,7 +1358,8 @@ write_var_or_type (const struct block *block, struct stoken name0)
 	    }
 	  else if (tail_index == name_len && nsyms == 0)
 	    {
-	      struct type *type = find_primitive_type (encoded_name);
+	      struct type *type = find_primitive_type (par_state,
+	      					       encoded_name);
 
 	      if (type != NULL)
 		return type;
@@ -1336,8 +1367,9 @@ write_var_or_type (const struct block *block, struct stoken name0)
 
 	  if (nsyms == 1)
 	    {
-	      write_var_from_sym (block, syms[0].block, syms[0].sym);
-	      write_selectors (encoded_name + tail_index);
+	      write_var_from_sym (par_state, block, syms[0].block,
+	      			  syms[0].sym);
+	      write_selectors (par_state, encoded_name + tail_index);
 	      return NULL;
 	    }
 	  else if (nsyms == 0) 
@@ -1346,9 +1378,9 @@ write_var_or_type (const struct block *block, struct stoken name0)
 		= ada_lookup_simple_minsym (encoded_name);
 	      if (msym.minsym != NULL)
 		{
-		  write_exp_msymbol (msym);
+		  write_exp_msymbol (par_state, msym);
 		  /* Maybe cause error here rather than later? FIXME? */
-		  write_selectors (encoded_name + tail_index);
+		  write_selectors (par_state, encoded_name + tail_index);
 		  return NULL;
 		}
 
@@ -1361,8 +1393,9 @@ write_var_or_type (const struct block *block, struct stoken name0)
 	    } 
 	  else
 	    {
-	      write_ambiguous_var (block, encoded_name, tail_index);
-	      write_selectors (encoded_name + tail_index);
+	      write_ambiguous_var (par_state, block, encoded_name,
+				   tail_index);
+	      write_selectors (par_state, encoded_name + tail_index);
 	      return NULL;
 	    }
 	}
@@ -1397,7 +1430,7 @@ write_var_or_type (const struct block *block, struct stoken name0)
    ambiguous name, one must write instead ((R) => 42). */
    
 static void
-write_name_assoc (struct stoken name)
+write_name_assoc (struct parser_state *par_state, struct stoken name)
 {
   if (strchr (name.ptr, '.') == NULL)
     {
@@ -1405,12 +1438,12 @@ write_name_assoc (struct stoken name)
       int nsyms = ada_lookup_symbol_list (name.ptr, expression_context_block,
 					  VAR_DOMAIN, &syms);
       if (nsyms != 1 || SYMBOL_CLASS (syms[0].sym) == LOC_TYPEDEF)
-	write_exp_op_with_string (OP_NAME, name);
+	write_exp_op_with_string (par_state, OP_NAME, name);
       else
-	write_var_from_sym (NULL, syms[0].block, syms[0].sym);
+	write_var_from_sym (par_state, NULL, syms[0].block, syms[0].sym);
     }
   else
-    if (write_var_or_type (NULL, name) != NULL)
+    if (write_var_or_type (par_state, NULL, name) != NULL)
       error (_("Invalid use of type."));
 }
 
@@ -1441,61 +1474,62 @@ convert_char_literal (struct type *type, LONGEST val)
 }
 
 static struct type *
-type_int (void)
+type_int (struct parser_state *par_state)
 {
-  return parse_type->builtin_int;
+  return parse_type (par_state)->builtin_int;
 }
 
 static struct type *
-type_long (void)
+type_long (struct parser_state *par_state)
 {
-  return parse_type->builtin_long;
+  return parse_type (par_state)->builtin_long;
 }
 
 static struct type *
-type_long_long (void)
+type_long_long (struct parser_state *par_state)
 {
-  return parse_type->builtin_long_long;
+  return parse_type (par_state)->builtin_long_long;
 }
 
 static struct type *
-type_float (void)
+type_float (struct parser_state *par_state)
 {
-  return parse_type->builtin_float;
+  return parse_type (par_state)->builtin_float;
 }
 
 static struct type *
-type_double (void)
+type_double (struct parser_state *par_state)
 {
-  return parse_type->builtin_double;
+  return parse_type (par_state)->builtin_double;
 }
 
 static struct type *
-type_long_double (void)
+type_long_double (struct parser_state *par_state)
 {
-  return parse_type->builtin_long_double;
+  return parse_type (par_state)->builtin_long_double;
 }
 
 static struct type *
-type_char (void)
+type_char (struct parser_state *par_state)
 {
-  return language_string_char_type (parse_language, parse_gdbarch);
+  return language_string_char_type (parse_language (par_state),
+  				    parse_gdbarch (par_state));
 }
 
 static struct type *
-type_boolean (void)
+type_boolean (struct parser_state *par_state)
 {
-  return parse_type->builtin_bool;
+  return parse_type (par_state)->builtin_bool;
 }
 
 static struct type *
-type_system_address (void)
+type_system_address (struct parser_state *par_state)
 {
   struct type *type 
-    = language_lookup_primitive_type_by_name (parse_language,
-					      parse_gdbarch,
+    = language_lookup_primitive_type_by_name (parse_language (par_state),
+					      parse_gdbarch (par_state),
 					      "system__address");
-  return  type != NULL ? type : parse_type->builtin_data_ptr;
+  return  type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
 }
 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 38df182..71827ae 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -13376,10 +13376,10 @@ emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
 }
 
 static int
-parse (void)
+parse (struct parser_state *ps)
 {
   warnings_issued = 0;
-  return ada_parse ();
+  return ada_parse (ps);
 }
 
 static const struct exp_descriptor ada_exp_descriptor = {
diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h
index c053278..6356cfa 100644
--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -23,6 +23,7 @@
 struct frame_info;
 struct inferior;
 struct type_print_options;
+struct parser_state;
 
 #include "value.h"
 #include "gdbtypes.h"
@@ -169,7 +170,7 @@ extern int ada_get_field_index (const struct type *type,
                                 const char *field_name,
                                 int maybe_missing);
 
-extern int ada_parse (void);    /* Defined in ada-exp.y */
+extern int ada_parse (struct parser_state *);    /* Defined in ada-exp.y */
 
 extern void ada_error (char *); /* Defined in ada-exp.y */
 
diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l
index 0787a0f..85c9d88 100644
--- a/gdb/ada-lex.l
+++ b/gdb/ada-lex.l
@@ -48,8 +48,9 @@ POSEXP  (e"+"?{NUM10})
 static char numbuf[NUMERAL_WIDTH];
  static void canonicalizeNumeral (char *s1, const char *);
 static struct stoken processString (const char*, int);
-static int processInt (const char *, const char *, const char *);
-static int processReal (const char *);
+static int processInt (struct parser_state *, const char *, const char *,
+		       const char *);
+static int processReal (struct parser_state *, const char *);
 static struct stoken processId (const char *, int);
 static int processAttribute (const char *);
 static int find_dot_all (const char *);
@@ -89,40 +90,42 @@ static int find_dot_all (const char *);
 
 {NUM10}{POSEXP}  {
 		   canonicalizeNumeral (numbuf, yytext);
-		   return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
+		   return processInt (pstate, NULL, numbuf,
+				      strrchr (numbuf, 'e') + 1);
 		 }
 
 {NUM10}          {
 		   canonicalizeNumeral (numbuf, yytext);
-		   return processInt (NULL, numbuf, NULL);
+		   return processInt (pstate, NULL, numbuf, NULL);
 		 }
 
 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
 		   canonicalizeNumeral (numbuf, yytext);
-    		   return processInt (numbuf,
+    		   return processInt (pstate, numbuf,
 				      strchr (numbuf, '#') + 1,
 				      strrchr(numbuf, '#') + 1);
 		 }
 
 {NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
 		   canonicalizeNumeral (numbuf, yytext);
-    		   return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
+    		   return processInt (pstate, numbuf, strchr (numbuf, '#') + 1,
+				      NULL);
 		 }
 
 "0x"{HEXDIG}+	{
 		  canonicalizeNumeral (numbuf, yytext+2);
-		  return processInt ("16#", numbuf, NULL);
+		  return processInt (pstate, "16#", numbuf, NULL);
 		}
 
 
 {NUM10}"."{NUM10}{EXP} {
 		   canonicalizeNumeral (numbuf, yytext);
-		   return processReal (numbuf);
+		   return processReal (pstate, numbuf);
 		}
 
 {NUM10}"."{NUM10} {
 		   canonicalizeNumeral (numbuf, yytext);
-		   return processReal (numbuf);
+		   return processReal (pstate, numbuf);
 		}
 
 {NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
@@ -134,14 +137,14 @@ static int find_dot_all (const char *);
 		}
 
 <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;
@@ -324,7 +327,8 @@ canonicalizeNumeral (char *s1, const char *s2)
  */
 
 static int
-processInt (const char *base0, const char *num0, const char *exp0)
+processInt (struct parser_state *par_state, const char *base0,
+	    const char *num0, const char *exp0)
 {
   ULONGEST result;
   long exp;
@@ -360,11 +364,11 @@ processInt (const char *base0, const char *num0, const char *exp0)
       exp -= 1;
     }
 
-  if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
-    yylval.typed_val.type = type_int ();
-  else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
-    yylval.typed_val.type = type_long ();
-  else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
+  if ((result >> (gdbarch_int_bit (parse_gdbarch (par_state))-1)) == 0)
+    yylval.typed_val.type = type_int (par_state);
+  else if ((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) == 0)
+    yylval.typed_val.type = type_long (par_state);
+  else if (((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) >> 1) == 0)
     {
       /* We have a number representable as an unsigned integer quantity.
          For consistency with the C treatment, we will treat it as an
@@ -374,7 +378,7 @@ processInt (const char *base0, const char *num0, const char *exp0)
          assignment does the trick (no, it doesn't; read the reference manual).
        */
       yylval.typed_val.type
-	= builtin_type (parse_gdbarch)->builtin_unsigned_long;
+	= builtin_type (parse_gdbarch (par_state))->builtin_unsigned_long;
       if (result & LONGEST_SIGN)
 	yylval.typed_val.val =
 	  (LONGEST) (result & ~LONGEST_SIGN)
@@ -384,24 +388,24 @@ processInt (const char *base0, const char *num0, const char *exp0)
       return INT;
     }
   else
-    yylval.typed_val.type = type_long_long ();
+    yylval.typed_val.type = type_long_long (par_state);
 
   yylval.typed_val.val = (LONGEST) result;
   return INT;
 }
 
 static int
-processReal (const char *num0)
+processReal (struct parser_state *par_state, const char *num0)
 {
   sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
 
-  yylval.typed_val_float.type = type_float ();
-  if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
+  yylval.typed_val_float.type = type_float (par_state);
+  if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch (par_state))
 			    / TARGET_CHAR_BIT)
-    yylval.typed_val_float.type = type_double ();
-  if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
+    yylval.typed_val_float.type = type_double (par_state);
+  if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch (par_state))
 			    / TARGET_CHAR_BIT)
-    yylval.typed_val_float.type = type_long_double ();
+    yylval.typed_val_float.type = type_long_double (par_state);
 
   return FLOAT;
 }
