From 3163898ec86b30d022a7ebf5bdec286c23cebd45 Mon Sep 17 00:00:00 2001
From: Tom Tromey <tom@tromey.com>
Date: Mon, 8 Mar 2021 07:27:57 -0700
Subject: [PATCH] Convert p-exp.y to use operations

This converts the Pascal parser to generate operations rather than
exp_elements.

gdb/ChangeLog
2021-03-08  Tom Tromey  <tom@tromey.com>

	* p-exp.y: Create operations.
	(pascal_language::parser): Update.
---
 gdb/ChangeLog |   5 +
 gdb/p-exp.y   | 267 +++++++++++++++++++++++---------------------------
 2 files changed, 130 insertions(+), 142 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 124eaafda97..5852e585989 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,8 @@
+2021-03-08  Tom Tromey  <tom@tromey.com>
+
+	* p-exp.y: Create operations.
+	(pascal_language::parser): Update.
+
 2021-03-08  Tom Tromey  <tom@tromey.com>
 
 	* d-exp.y: Create operations.
diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index b025ac36070..fc9984c996a 100644
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -55,6 +55,7 @@
 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols.  */
 #include "block.h"
 #include "completer.h"
+#include "expop.h"
 
 #define parse_type(ps) builtin_type (ps->gdbarch ())
 
@@ -78,6 +79,8 @@ static int yylex (void);
 static void yyerror (const char *);
 
 static char *uptok (const char *, int);
+
+using namespace expr;
 %}
 
 /* Although the yacc "value" of an expression is not used,
@@ -203,44 +206,43 @@ normal_start	:
 	;
 
 type_exp:	type
-			{ write_exp_elt_opcode (pstate, OP_TYPE);
-			  write_exp_elt_type (pstate, $1);
-			  write_exp_elt_opcode (pstate, OP_TYPE);
+			{
+			  pstate->push_new<type_operation> ($1);
 			  current_type = $1; } ;
 
 /* Expressions, including the comma operator.  */
 exp1	:	exp
 	|	exp1 ',' exp
-			{ write_exp_elt_opcode (pstate, BINOP_COMMA); }
+			{ pstate->wrap2<comma_operation> (); }
 	;
 
 /* Expressions, not including the comma operator.  */
 exp	:	exp '^'   %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_IND);
+			{ pstate->wrap<unop_ind_operation> ();
 			  if (current_type)
 			    current_type = TYPE_TARGET_TYPE (current_type); }
 	;
 
 exp	:	'@' exp    %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_ADDR);
+			{ pstate->wrap<unop_addr_operation> ();
 			  if (current_type)
 			    current_type = TYPE_POINTER_TYPE (current_type); }
 	;
 
 exp	:	'-' exp    %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_NEG); }
+			{ pstate->wrap<unary_neg_operation> (); }
 	;
 
 exp	:	NOT exp    %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
+			{ pstate->wrap<unary_logical_not_operation> (); }
 	;
 
 exp	:	INCREMENT '(' exp ')'   %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
+			{ pstate->wrap<preinc_operation> (); }
 	;
 
 exp	:	DECREMENT  '(' exp ')'   %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
+			{ pstate->wrap<predec_operation> (); }
 	;
 
 
@@ -249,9 +251,9 @@ field_exp	:	exp '.'	%prec UNARY
 	;
 
 exp	:	field_exp FIELDNAME
-			{ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
-			  write_exp_string (pstate, $2);
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+			{
+			  pstate->push_new<structop_operation>
+			    (pstate->pop (), copy_name ($2));
 			  search_field = 0;
 			  if (current_type)
 			    {
@@ -267,9 +269,9 @@ exp	:	field_exp FIELDNAME
 
 
 exp	:	field_exp name
-			{ write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
-			  write_exp_string (pstate, $2);
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+			{
+			  pstate->push_new<structop_operation>
+			    (pstate->pop (), copy_name ($2));
 			  search_field = 0;
 			  if (current_type)
 			    {
@@ -283,19 +285,21 @@ exp	:	field_exp name
 			}
 	;
 exp	:	field_exp  name COMPLETE
-			{ pstate->mark_struct_expression ();
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
-			  write_exp_string (pstate, $2);
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
+			{
+			  structop_base_operation *op
+			    = new structop_ptr_operation (pstate->pop (),
+							  copy_name ($2));
+			  pstate->mark_struct_expression (op);
+			  pstate->push (operation_up (op));
+			}
 	;
 exp	:	field_exp COMPLETE
-			{ struct stoken s;
-			  pstate->mark_struct_expression ();
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
-			  s.ptr = "";
-			  s.length = 0;
-			  write_exp_string (pstate, s);
-			  write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
+			{
+			  structop_base_operation *op
+			    = new structop_ptr_operation (pstate->pop (), "");
+			  pstate->mark_struct_expression (op);
+			  pstate->push (operation_up (op));
+			}
 	;
 
 exp	:	exp '['
@@ -306,24 +310,16 @@ exp	:	exp '['
 						     NULL, NULL, &arrayname);
 			  if (arrayfieldindex)
 			    {
-			      struct stoken stringsval;
-			      char *buf;
-
-			      buf = (char *) alloca (strlen (arrayname) + 1);
-			      stringsval.ptr = buf;
-			      stringsval.length = strlen (arrayname);
-			      strcpy (buf, arrayname);
 			      current_type
 				= (current_type
 				   ->field (arrayfieldindex - 1).type ());
-			      write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
-			      write_exp_string (pstate, stringsval);
-			      write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
+			      pstate->push_new<structop_operation>
+				(pstate->pop (), arrayname);
 			    }
 			  push_current_type ();  }
 		exp1 ']'
 			{ pop_current_type ();
-			  write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
+			  pstate->wrap2<subscript_operation> ();
 			  if (current_type)
 			    current_type = TYPE_TARGET_TYPE (current_type); }
 	;
@@ -334,10 +330,11 @@ exp	:	exp '('
 			{ push_current_type ();
 			  pstate->start_arglist (); }
 		arglist ')'	%prec ARROW
-			{ write_exp_elt_opcode (pstate, OP_FUNCALL);
-			  write_exp_elt_longcst (pstate,
-						 pstate->end_arglist ());
-			  write_exp_elt_opcode (pstate, OP_FUNCALL);
+			{
+			  std::vector<operation_up> args
+			    = pstate->pop_vector (pstate->end_arglist ());
+			  pstate->push_new<funcall_operation>
+			    (pstate->pop (), std::move (args));
 			  pop_current_type ();
 			  if (current_type)
  	  		    current_type = TYPE_TARGET_TYPE (current_type);
@@ -358,11 +355,10 @@ exp	:	type '(' exp ')' %prec UNARY
 			      if ((current_type->code () == TYPE_CODE_PTR)
 				  && (TYPE_TARGET_TYPE (current_type)->code () == TYPE_CODE_STRUCT)
 				  && (($1)->code () == TYPE_CODE_STRUCT))
-				write_exp_elt_opcode (pstate, UNOP_IND);
+				pstate->wrap<unop_ind_operation> ();
 			    }
-			  write_exp_elt_opcode (pstate, UNOP_CAST);
-			  write_exp_elt_type (pstate, $1);
-			  write_exp_elt_opcode (pstate, UNOP_CAST);
+			  pstate->push_new<unop_cast_operation>
+			    (pstate->pop (), $1);
 			  current_type = $1; }
 	;
 
@@ -373,7 +369,7 @@ exp	:	'(' exp1 ')'
 /* Binary operators in order of decreasing precedence.  */
 
 exp	:	exp '*' exp
-			{ write_exp_elt_opcode (pstate, BINOP_MUL); }
+			{ pstate->wrap2<mul_operation> (); }
 	;
 
 exp	:	exp '/' {
@@ -385,138 +381,141 @@ exp	:	exp '/' {
 			  if (leftdiv_is_integer && current_type
 			      && is_integral_type (current_type))
 			    {
-			      write_exp_elt_opcode (pstate, UNOP_CAST);
-			      write_exp_elt_type (pstate,
-						  parse_type (pstate)
-						  ->builtin_long_double);
+			      pstate->push_new<unop_cast_operation>
+				(pstate->pop (),
+				 parse_type (pstate)->builtin_long_double);
 			      current_type
 				= parse_type (pstate)->builtin_long_double;
-			      write_exp_elt_opcode (pstate, UNOP_CAST);
 			      leftdiv_is_integer = 0;
 			    }
 
-			  write_exp_elt_opcode (pstate, BINOP_DIV);
+			  pstate->wrap2<div_operation> ();
 			}
 	;
 
 exp	:	exp DIV exp
-			{ write_exp_elt_opcode (pstate, BINOP_INTDIV); }
+			{ pstate->wrap2<intdiv_operation> (); }
 	;
 
 exp	:	exp MOD exp
-			{ write_exp_elt_opcode (pstate, BINOP_REM); }
+			{ pstate->wrap2<rem_operation> (); }
 	;
 
 exp	:	exp '+' exp
-			{ write_exp_elt_opcode (pstate, BINOP_ADD); }
+			{ pstate->wrap2<add_operation> (); }
 	;
 
 exp	:	exp '-' exp
-			{ write_exp_elt_opcode (pstate, BINOP_SUB); }
+			{ pstate->wrap2<sub_operation> (); }
 	;
 
 exp	:	exp LSH exp
-			{ write_exp_elt_opcode (pstate, BINOP_LSH); }
+			{ pstate->wrap2<lsh_operation> (); }
 	;
 
 exp	:	exp RSH exp
-			{ write_exp_elt_opcode (pstate, BINOP_RSH); }
+			{ pstate->wrap2<rsh_operation> (); }
 	;
 
 exp	:	exp '=' exp
-			{ write_exp_elt_opcode (pstate, BINOP_EQUAL);
+			{
+			  pstate->wrap2<equal_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp NOTEQUAL exp
-			{ write_exp_elt_opcode (pstate, BINOP_NOTEQUAL);
+			{
+			  pstate->wrap2<notequal_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp LEQ exp
-			{ write_exp_elt_opcode (pstate, BINOP_LEQ);
+			{
+			  pstate->wrap2<leq_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp GEQ exp
-			{ write_exp_elt_opcode (pstate, BINOP_GEQ);
+			{
+			  pstate->wrap2<geq_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp '<' exp
-			{ write_exp_elt_opcode (pstate, BINOP_LESS);
+			{
+			  pstate->wrap2<less_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp '>' exp
-			{ write_exp_elt_opcode (pstate, BINOP_GTR);
+			{
+			  pstate->wrap2<gtr_operation> ();
 			  current_type = parse_type (pstate)->builtin_bool;
 			}
 	;
 
 exp	:	exp ANDAND exp
-			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
+			{ pstate->wrap2<bitwise_and_operation> (); }
 	;
 
 exp	:	exp XOR exp
-			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
+			{ pstate->wrap2<bitwise_xor_operation> (); }
 	;
 
 exp	:	exp OR exp
-			{ write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
+			{ pstate->wrap2<bitwise_ior_operation> (); }
 	;
 
 exp	:	exp ASSIGN exp
-			{ write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
+			{ pstate->wrap2<assign_operation> (); }
 	;
 
 exp	:	TRUEKEYWORD
-			{ write_exp_elt_opcode (pstate, OP_BOOL);
-			  write_exp_elt_longcst (pstate, (LONGEST) $1);
+			{
+			  pstate->push_new<bool_operation> ($1);
 			  current_type = parse_type (pstate)->builtin_bool;
-			  write_exp_elt_opcode (pstate, OP_BOOL); }
+			}
 	;
 
 exp	:	FALSEKEYWORD
-			{ write_exp_elt_opcode (pstate, OP_BOOL);
-			  write_exp_elt_longcst (pstate, (LONGEST) $1);
+			{
+			  pstate->push_new<bool_operation> ($1);
 			  current_type = parse_type (pstate)->builtin_bool;
-			  write_exp_elt_opcode (pstate, OP_BOOL); }
+			}
 	;
 
 exp	:	INT
-			{ write_exp_elt_opcode (pstate, OP_LONG);
-			  write_exp_elt_type (pstate, $1.type);
+			{
+			  pstate->push_new<long_const_operation>
+			    ($1.type, $1.val);
 			  current_type = $1.type;
-			  write_exp_elt_longcst (pstate, (LONGEST)($1.val));
-			  write_exp_elt_opcode (pstate, OP_LONG); }
+			}
 	;
 
 exp	:	NAME_OR_INT
 			{ YYSTYPE val;
 			  parse_number (pstate, $1.stoken.ptr,
 					$1.stoken.length, 0, &val);
-			  write_exp_elt_opcode (pstate, OP_LONG);
-			  write_exp_elt_type (pstate, val.typed_val_int.type);
+			  pstate->push_new<long_const_operation>
+			    (val.typed_val_int.type,
+			     val.typed_val_int.val);
 			  current_type = val.typed_val_int.type;
-			  write_exp_elt_longcst (pstate, (LONGEST)
-						 val.typed_val_int.val);
-			  write_exp_elt_opcode (pstate, OP_LONG);
 			}
 	;
 
 
 exp	:	FLOAT
-			{ write_exp_elt_opcode (pstate, OP_FLOAT);
-			  write_exp_elt_type (pstate, $1.type);
-			  current_type = $1.type;
-			  write_exp_elt_floatcst (pstate, $1.val);
-			  write_exp_elt_opcode (pstate, OP_FLOAT); }
+			{
+			  float_data data;
+			  std::copy (std::begin ($1.val), std::end ($1.val),
+				     std::begin (data));
+			  pstate->push_new<float_const_operation> ($1.type, data);
+			}
 	;
 
 exp	:	variable
@@ -524,7 +523,7 @@ exp	:	variable
 
 exp	:	DOLLAR_VARIABLE
 			{
-			  write_dollar_variable (pstate, $1);
+			  pstate->push_dollar ($1);
 
 			  /* $ is the normal prefix for pascal
 			     hexadecimal values but this conflicts
@@ -549,18 +548,16 @@ exp	:	DOLLAR_VARIABLE
  	;
 
 exp	:	SIZEOF '(' type ')'	%prec UNARY
-			{ write_exp_elt_opcode (pstate, OP_LONG);
-			  write_exp_elt_type (pstate,
-					    parse_type (pstate)->builtin_int);
+			{
 			  current_type = parse_type (pstate)->builtin_int;
 			  $3 = check_typedef ($3);
-			  write_exp_elt_longcst (pstate,
-						 (LONGEST) TYPE_LENGTH ($3));
-			  write_exp_elt_opcode (pstate, OP_LONG); }
+			  pstate->push_new<long_const_operation>
+			    (parse_type (pstate)->builtin_int,
+			     TYPE_LENGTH ($3)); }
 	;
 
 exp	:	SIZEOF  '(' exp ')'      %prec UNARY
-			{ write_exp_elt_opcode (pstate, UNOP_SIZEOF);
+			{ pstate->wrap<unop_sizeof_operation> ();
 			  current_type = parse_type (pstate)->builtin_int; }
 
 exp	:	STRING
@@ -571,27 +568,17 @@ exp	:	STRING
 			     string.  */
 			  const char *sp = $1.ptr; int count = $1.length;
 
-			  while (count-- > 0)
-			    {
-			      write_exp_elt_opcode (pstate, OP_LONG);
-			      write_exp_elt_type (pstate,
-						  parse_type (pstate)
-						  ->builtin_char);
-			      write_exp_elt_longcst (pstate,
-						     (LONGEST) (*sp++));
-			      write_exp_elt_opcode (pstate, OP_LONG);
-			    }
-			  write_exp_elt_opcode (pstate, OP_LONG);
-			  write_exp_elt_type (pstate,
-					      parse_type (pstate)
-					      ->builtin_char);
-			  write_exp_elt_longcst (pstate, (LONGEST)'\0');
-			  write_exp_elt_opcode (pstate, OP_LONG);
-			  write_exp_elt_opcode (pstate, OP_ARRAY);
-			  write_exp_elt_longcst (pstate, (LONGEST) 0);
-			  write_exp_elt_longcst (pstate,
-						 (LONGEST) ($1.length));
-			  write_exp_elt_opcode (pstate, OP_ARRAY); }
+			  std::vector<operation_up> args (count + 1);
+			  for (int i = 0; i < count; ++i)
+			    args[i] = (make_operation<long_const_operation>
+				       (parse_type (pstate)->builtin_char,
+					*sp++));
+			  args[count] = (make_operation<long_const_operation>
+					 (parse_type (pstate)->builtin_char,
+					  '\0'));
+			  pstate->push_new<array_operation>
+			    (0, $1.length, std::move (args));
+			}
 	;
 
 /* Object pascal  */
@@ -599,8 +586,7 @@ exp	:	THIS
 			{
 			  struct value * this_val;
 			  struct type * this_type;
-			  write_exp_elt_opcode (pstate, OP_THIS);
-			  write_exp_elt_opcode (pstate, OP_THIS);
+			  pstate->push_new<op_this_operation> ();
 			  /* We need type of this.  */
 			  this_val
 			    = value_of_this_silent (pstate->language ());
@@ -613,7 +599,7 @@ exp	:	THIS
 			      if (this_type->code () == TYPE_CODE_PTR)
 				{
 				  this_type = TYPE_TARGET_TYPE (this_type);
-				  write_exp_elt_opcode (pstate, UNOP_IND);
+				  pstate->wrap<unop_ind_operation> ();
 				}
 			    }
 
@@ -665,10 +651,9 @@ variable:	block COLONCOLON name
 			    error (_("No symbol \"%s\" in specified context."),
 				   copy.c_str ());
 
-			  write_exp_elt_opcode (pstate, OP_VAR_VALUE);
-			  write_exp_elt_block (pstate, sym.block);
-			  write_exp_elt_sym (pstate, sym.symbol);
-			  write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
+			  pstate->push_new<var_value_operation>
+			    (sym.symbol, sym.block);
+			}
 	;
 
 qualified_name:	typebase COLONCOLON name
@@ -680,10 +665,8 @@ qualified_name:	typebase COLONCOLON name
 			    error (_("`%s' is not defined as an aggregate type."),
 				   type->name ());
 
-			  write_exp_elt_opcode (pstate, OP_SCOPE);
-			  write_exp_elt_type (pstate, type);
-			  write_exp_string (pstate, $3);
-			  write_exp_elt_opcode (pstate, OP_SCOPE);
+			  pstate->push_new<scope_operation>
+			    (type, copy_name ($3));
 			}
 	;
 
@@ -695,8 +678,7 @@ variable:	qualified_name
 			  struct block_symbol sym
 			    = lookup_symbol (name.c_str (), nullptr,
 					     VAR_DOMAIN, nullptr);
-			  write_exp_symbol_reference (pstate, name.c_str (),
-						      sym);
+			  pstate->push_symbol (name.c_str (), sym);
 			}
 	;
 
@@ -708,10 +690,8 @@ variable:	name_not_typename
 			      if (symbol_read_needs_frame (sym.symbol))
 				pstate->block_tracker->update (sym);
 
-			      write_exp_elt_opcode (pstate, OP_VAR_VALUE);
-			      write_exp_elt_block (pstate, sym.block);
-			      write_exp_elt_sym (pstate, sym.symbol);
-			      write_exp_elt_opcode (pstate, OP_VAR_VALUE);
+			      pstate->push_new<var_value_operation>
+				(sym.symbol, sym.block);
 			      current_type = sym.symbol->type; }
 			  else if ($1.is_a_field_of_this)
 			    {
@@ -721,11 +701,10 @@ variable:	name_not_typename
 				 not inadvertently convert from a method call
 				 to data ref.  */
 			      pstate->block_tracker->update (sym);
-			      write_exp_elt_opcode (pstate, OP_THIS);
-			      write_exp_elt_opcode (pstate, OP_THIS);
-			      write_exp_elt_opcode (pstate, STRUCTOP_PTR);
-			      write_exp_string (pstate, $1.stoken);
-			      write_exp_elt_opcode (pstate, STRUCTOP_PTR);
+			      operation_up thisop
+				= make_operation<op_this_operation> ();
+			      pstate->push_new<structop_operation>
+				(std::move (thisop), copy_name ($1.stoken));
 			      /* We need type of this.  */
 			      this_val
 				= value_of_this_silent (pstate->language ());
@@ -748,7 +727,8 @@ variable:	name_not_typename
 			      msymbol =
 				lookup_bound_minimal_symbol (arg.c_str ());
 			      if (msymbol.minsym != NULL)
-				write_exp_msymbol (pstate, msymbol);
+				pstate->push_new<var_msym_value_operation>
+				  (msymbol.minsym, msymbol.objfile);
 			      else if (!have_full_symbols ()
 				       && !have_partial_symbols ())
 				error (_("No symbol table is loaded.  "
@@ -1716,7 +1696,10 @@ pascal_language::parser (struct parser_state *par_state) const
   pstate = par_state;
   paren_depth = 0;
 
-  return yyparse ();
+  int result = yyparse ();
+  if (!result)
+    pstate->set_operation (pstate->pop ());
+  return result;
 }
 
 static void
-- 
2.30.2