[PATCH 181/203] Convert p-exp.y to use operations

Tom Tromey
2021-01-01T21:49:41Z

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

gdb/ChangeLog
2021-01-01 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/p-exp.y b/gdb/p-exp.y
index 637369e0404..87fabc2ec11 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));
}
;

@@ -697,8 +680,7 @@ variable: qualified_name
lookup_symbol (name.c_str (),
(const struct block *) NULL,
VAR_DOMAIN, NULL).symbol;
- write_exp_symbol_reference (pstate, name.c_str (),
- sym);
+ pstate->push_symbol (name.c_str (), sym);
}
;

@@ -710,10 +692,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)
{
@@ -723,11 +703,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 ());
@@ -750,7 +729,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. "
@@ -1718,7 +1698,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.26.2