Remove `expout*' globals from parser-defs.h

This commit removes the "expout*" globals from our parser code, turning
them into a structure that is passed when an expression needs to be
evaluated.  This is the initial step to make our parser less
"globalized".

This is mostly a mechanical patch, which creates a structure containing
the "expout*" globals and then modify all the functions that handle them
in order to take the structure as argument.  It is big, and has been
reviewed at least 4 times, so I think everything is covered.

Below you can see the message links from the discussions:

- First attempt:

<https://sourceware.org/ml/gdb-patches/2012-01/msg00522.html>
Message-ID: <m3k44s7qej.fsf@gmail.com>

- Second attempt:

<https://sourceware.org/ml/gdb-patches/2012-06/msg00054.html>
Message-Id: <1338665528-5932-1-git-send-email-sergiodj@redhat.com>

- Third attempt:

<https://sourceware.org/ml/gdb-patches/2014-01/msg00949.html>
Message-Id: <1390629467-27139-1-git-send-email-sergiodj@redhat.com>

- Fourth (last) attempt:

<https://sourceware.org/ml/gdb-patches/2014-03/msg00546.html>
Message-Id: <1395463432-29750-1-git-send-email-sergiodj@redhat.com>

gdb/
2014-03-27  Sergio Durigan Junior  <sergiodj@redhat.com>

	Remove some globals from our parser.
	* language.c (unk_lang_parser): Add "struct parser_state"
	argument.
	* language.h (struct language_defn) <la_parser>: Likewise.
	* parse.c (expout, expout_size, expout_ptr): Remove variables.
	(initialize_expout): Add "struct parser_state" argument.
	Rewrite function to use the parser state.
	(reallocate_expout, write_exp_elt, write_exp_elt_opcode,
	write_exp_elt_sym, write_exp_elt_block, write_exp_elt_objfile,
	write_exp_elt_longcst, write_exp_elt_dblcst,
	write_exp_elt_decfloatcst, write_exp_elt_type,
	write_exp_elt_intern, write_exp_string, write_exp_string_vector,
	write_exp_bitstring, write_exp_msymbol, mark_struct_expression,
	write_dollar_variable): Likewise.
	(parse_exp_in_context_1): Use parser state.
	(insert_type_address_space): Add "struct parser_state" argument.
	Use parser state.
	(increase_expout_size): New function.
	* parser-defs.h: Forward declare "struct language_defn" and
	"struct parser_state".
	(expout, expout_size, expout_ptr): Remove extern declarations.
	(parse_gdbarch, parse_language): Rewrite macro declarations to
	accept the parser state.
	(struct parser_state): New struct.
	(initialize_expout, reallocate_expout, write_exp_elt_opcode,
	write_exp_elt_sym, write_exp_elt_longcst, write_exp_elt_dblcst,
	write_exp_elt_decfloatcst, write_exp_elt_type,
	write_exp_elt_intern, write_exp_string, write_exp_string_vector,
	write_exp_bitstring, write_exp_elt_block, write_exp_elt_objfile,
	write_exp_msymbol, write_dollar_variable,
	mark_struct_expression, insert_type_address_space): Add "struct
	parser_state" argument.
	(increase_expout_size): New function.
	* utils.c (do_clear_parser_state): New function.
	(make_cleanup_clear_parser_state): Likewise.
	* utils.h (make_cleanup_clear_parser_state): New function
	prototype.
	* aarch64-linux-tdep.c (aarch64_stap_parse_special_token):
	Update calls to write_exp* in order to pass the parser state.
	* arm-linux-tdep.c (arm_stap_parse_special_token): Likewise.
	* i386-tdep.c (i386_stap_parse_special_token_triplet): Likewise.
	(i386_stap_parse_special_token_three_arg_disp): Likewise.
	* ppc-linux-tdep.c (ppc_stap_parse_special_token): Likewise.
	* stap-probe.c (stap_parse_register_operand): Likewise.
	(stap_parse_single_operand): Likewise.
	(stap_parse_argument_1): Likewise.
	(stap_parse_argument): Use parser state.
	* stap-probe.h: Include "parser-defs.h".
	(struct stap_parse_info) <pstate>: New field.
	* c-exp.y (parse_type): Rewrite to use parser state.
	(yyparse): Redefine to c_parse_internal.
	(pstate): New global variable.
	(parse_number): Add "struct parser_state" argument.
	(write_destructor_name): Likewise.
	(type_exp): Update calls to write_exp* and similars in order to
	use parser state.
	(exp1, exp, variable, qualified_name, space_identifier,
	typename, typebase): Likewise.
	(write_destructor_name, parse_number, lex_one_token,
	classify_name, classify_inner_name, c_parse): Add "struct
	parser_state" argument.  Update function to use parser state.
	* c-lang.h: Forward declare "struct parser_state".
	(c_parse): Add "struct parser_state" argument.
	* ada-exp.y (parse_type): Rewrite macro to use parser state.
	(yyparse): Redefine macro to ada_parse_internal.
	(pstate): New variable.
	(write_int, write_object_renaming, write_var_or_type,
	write_name_assoc, write_exp_op_with_string, write_ambiguous_var,
	type_int, type_long, type_long_long, type_float, type_double,
	type_long_double, type_char, type_boolean, type_system_address):
	Add "struct parser_state" argument.
	(exp1, primary, simple_exp, relation, and_exp, and_then_exp,
	or_exp, or_else_exp, xor_exp, type_prefix, opt_type_prefix,
	var_or_type, aggregate, aggregate_component_list,
	positional_list, others, component_group,
	component_associations): Update calls to write_exp* and similar
	functions in order to use parser state.
	(ada_parse, write_var_from_sym, write_int,
	write_exp_op_with_string, write_object_renaming,
	find_primitive_type, write_selectors, write_ambiguous_var,
	write_var_or_type, write_name_assoc, type_int, type_long,
	type_long_long, type_float, type_double, type_long_double,
	type_char, type_boolean, type_system_address): Add "struct
	parser_state" argument.  Adjust function to use parser state.
	* ada-lang.c (parse): Likewise.
	* ada-lang.h: Forward declare "struct parser_state".
	(ada_parse): Add "struct parser_state" argument.
	* ada-lex.l (processInt, processReal): Likewise.  Adjust all
	calls to both functions.
	* f-exp.y (parse_type, parse_f_type): Rewrite macros to use
	parser state.
	(yyparse): Redefine macro to f_parse_internal.
	(pstate): New variable.
	(parse_number): Add "struct parser_state" argument.
	(type_exp, exp, subrange, typebase): Update calls to write_exp*
	and similars in order to use parser state.
	(parse_number): Adjust code to use parser state.
	(yylex): Likewise.
	(f_parse): New function.
	* f-lang.h: Forward declare "struct parser_state".
	(f_parse): Add "struct parser_state" argument.
	* jv-exp.y (parse_type, parse_java_type): Rewrite macros to use
	parser state.
	(yyparse): Redefine macro for java_parse_internal.
	(pstate): New variable.
	(push_expression_name, push_expression_name, insert_exp): Add
	"struct parser_state" argument.
	(type_exp, StringLiteral, Literal, PrimitiveType, IntegralType,
	FloatingPointType, exp1, PrimaryNoNewArray, FieldAccess,
	FuncStart, MethodInvocation, ArrayAccess, PostfixExpression,
	PostIncrementExpression, PostDecrementExpression,
	UnaryExpression, PreIncrementExpression, PreDecrementExpression,
	UnaryExpressionNotPlusMinus, CastExpression,
	MultiplicativeExpression, AdditiveExpression, ShiftExpression,
	RelationalExpression, EqualityExpression, AndExpression,
	ExclusiveOrExpression, InclusiveOrExpression,
	ConditionalAndExpression, ConditionalOrExpression,
	ConditionalExpression, Assignment, LeftHandSide): Update
	calls to write_exp* and similars in order to use parser state.
	(parse_number): Ajust code to use parser state.
	(yylex): Likewise.
	(java_parse): New function.
	(push_variable): Add "struct parser_state" argument.  Adjust
	code to user parser state.
	(push_fieldnames, push_qualified_expression_name,
	push_expression_name, insert_exp): Likewise.
	* jv-lang.h: Forward declare "struct parser_state".
	(java_parse): Add "struct parser_state" argument.
	* m2-exp.y (parse_type, parse_m2_type): Rewrite macros to use
	parser state.
	(yyparse): Redefine macro to m2_parse_internal.
	(pstate): New variable.
	(type_exp, exp, fblock, variable, type): Update calls to
	write_exp* and similars to use parser state.
	(yylex): Likewise.
	(m2_parse): New function.
	* m2-lang.h: Forward declare "struct parser_state".
	(m2_parse): Add "struct parser_state" argument.
	* objc-lang.c (end_msglist): Add "struct parser_state" argument.
	* objc-lang.h: Forward declare "struct parser_state".
	(end_msglist): Add "struct parser_state" argument.
	* p-exp.y (parse_type): Rewrite macro to use parser state.
	(yyparse): Redefine macro to pascal_parse_internal.
	(pstate): New variable.
	(parse_number): Add "struct parser_state" argument.
	(type_exp, exp1, exp, qualified_name, variable): Update calls to
	write_exp* and similars in order to use parser state.
	(parse_number, yylex): Adjust code to use parser state.
	(pascal_parse): New function.
	* p-lang.h: Forward declare "struct parser_state".
	(pascal_parse): Add "struct parser_state" argument.
	* go-exp.y (parse_type): Rewrite macro to use parser state.
	(yyparse): Redefine macro to go_parse_internal.
	(pstate): New variable.
	(parse_number): Add "struct parser_state" argument.
	(type_exp, exp1, exp, variable, type): Update calls to
	write_exp* and similars in order to use parser state.
	(parse_number, lex_one_token, classify_name, yylex): Adjust code
	to use parser state.
	(go_parse): Likewise.
	* go-lang.h: Forward declare "struct parser_state".
	(go_parse): Add "struct parser_state" argument.

1 files changed, 29 insertions, 25 deletions

diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l
index 0787a0f..9632073 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;
 }