[PATCH 182/203] Convert m2-exp.y to use operations

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

This converts the Modula-2 parser to generate operations rather than
exp_elements.

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

* m2-exp.y: Create operations.
(m2_language::parser): Update.
---
gdb/ChangeLog | 5 ++
gdb/m2-exp.y | 234 ++++++++++++++++++++++++--------------------------
2 files changed, 117 insertions(+), 122 deletions(-)

diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index d94cf6905fe..43cbd3ebf73 100644
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -47,6 +47,7 @@
#include "symfile.h" /* Required by objfiles.h. */
#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
#include "block.h"
+#include "m2-exp.h"

#define parse_type(ps) builtin_type (ps->gdbarch ())
#define parse_m2_type(ps) builtin_m2_type (ps->gdbarch ())
@@ -72,6 +73,7 @@ static int parse_number (int);
/* The sign of the number being parsed. */
static int number_sign = 1;

+using namespace expr;
%}

/* Although the yacc "value" of an expression is not used,
@@ -153,31 +155,28 @@ start : exp
;

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); }
;

/* Expressions */

exp : exp '^' %prec UNARY
- { write_exp_elt_opcode (pstate, UNOP_IND); }
+ { pstate->wrap<unop_ind_operation> (); }
;

exp : '-'
{ number_sign = -1; }
exp %prec UNARY
{ number_sign = 1;
- write_exp_elt_opcode (pstate, UNOP_NEG); }
+ pstate->wrap<unary_neg_operation> (); }
;

exp : '+' exp %prec UNARY
- { write_exp_elt_opcode (pstate, UNOP_PLUS); }
+ { pstate->wrap<unary_plus_operation> (); }
;

exp : not_exp exp %prec UNARY
- { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
+ { pstate->wrap<unary_logical_not_operation> (); }
;

not_exp : NOT
@@ -185,91 +184,90 @@ not_exp : NOT
;

exp : CAP '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_CAP); }
+ { error (_("CAP function is not implemented")); }
;

exp : ORD '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_ORD); }
+ { error (_("ORD function is not implemented")); }
;

exp : ABS '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_ABS); }
+ { error (_("ABS function is not implemented")); }
;

exp : HIGH '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_HIGH); }
+ { pstate->wrap<m2_unop_high_operation> (); }
;

exp : MIN_FUNC '(' type ')'
- { write_exp_elt_opcode (pstate, UNOP_MIN);
- write_exp_elt_type (pstate, $3);
- write_exp_elt_opcode (pstate, UNOP_MIN); }
+ { error (_("MIN function is not implemented")); }
;

exp : MAX_FUNC '(' type ')'
- { write_exp_elt_opcode (pstate, UNOP_MAX);
- write_exp_elt_type (pstate, $3);
- write_exp_elt_opcode (pstate, UNOP_MAX); }
+ { error (_("MAX function is not implemented")); }
;

exp : FLOAT_FUNC '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_FLOAT); }
+ { error (_("FLOAT function is not implemented")); }
;

exp : VAL '(' type ',' exp ')'
- { write_exp_elt_opcode (pstate, BINOP_VAL);
- write_exp_elt_type (pstate, $3);
- write_exp_elt_opcode (pstate, BINOP_VAL); }
+ { error (_("VAL function is not implemented")); }
;

exp : CHR '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_CHR); }
+ { error (_("CHR function is not implemented")); }
;

exp : ODD '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_ODD); }
+ { error (_("ODD function is not implemented")); }
;

exp : TRUNC '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_TRUNC); }
+ { error (_("TRUNC function is not implemented")); }
;

exp : TSIZE '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
+ { pstate->wrap<unop_sizeof_operation> (); }
;

exp : SIZE exp %prec UNARY
- { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
+ { pstate->wrap<unop_sizeof_operation> (); }
;

exp : INC '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
+ { pstate->wrap<preinc_operation> (); }
;

exp : INC '(' exp ',' exp ')'
- { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
- write_exp_elt_opcode (pstate, BINOP_ADD);
- write_exp_elt_opcode (pstate,
- BINOP_ASSIGN_MODIFY); }
+ {
+ operation_up rhs = pstate->pop ();
+ operation_up lhs = pstate->pop ();
+ pstate->push_new<assign_modify_operation>
+ (BINOP_ADD, std::move (lhs), std::move (rhs));
+ }
;

exp : DEC '(' exp ')'
- { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT);}
+ { pstate->wrap<predec_operation> (); }
;

exp : DEC '(' exp ',' exp ')'
- { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
- write_exp_elt_opcode (pstate, BINOP_SUB);
- write_exp_elt_opcode (pstate,
- BINOP_ASSIGN_MODIFY); }
+ {
+ operation_up rhs = pstate->pop ();
+ operation_up lhs = pstate->pop ();
+ pstate->push_new<assign_modify_operation>
+ (BINOP_SUB, std::move (lhs), std::move (rhs));
+ }
;

exp : exp DOT NAME
- { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
- write_exp_string (pstate, $3);
- write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
- ;
+ {
+ pstate->push_new<structop_operation>
+ (pstate->pop (), copy_name ($3));
+ }
+;

exp : set
;
@@ -302,10 +300,10 @@ exp : exp '['
non_empty_arglist ']' %prec DOT
{
gdb_assert (pstate->arglist_len > 0);
- write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
- write_exp_elt_longcst (pstate,
- pstate->end_arglist());
- write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
+ std::vector<operation_up> args
+ = pstate->pop_vector (pstate->end_arglist ());
+ pstate->push_new<multi_subscript_operation>
+ (pstate->pop (), std::move (args));
}
;

@@ -314,10 +312,12 @@ exp : exp '('
being accumulated by an outer function call. */
{ pstate->start_arglist (); }
arglist ')' %prec DOT
- { 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));
+ }
;

arglist :
@@ -343,15 +343,17 @@ non_empty_arglist

/* GDB construct */
exp : '{' type '}' exp %prec UNARY
- { write_exp_elt_opcode (pstate, UNOP_MEMVAL);
- write_exp_elt_type (pstate, $2);
- write_exp_elt_opcode (pstate, UNOP_MEMVAL); }
+ {
+ pstate->push_new<unop_memval_operation>
+ (pstate->pop (), $2);
+ }
;

exp : type '(' exp ')' %prec UNARY
- { 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);
+ }
;

exp : '(' exp ')'
@@ -363,140 +365,127 @@ exp : '(' exp ')'

/* GDB construct */
exp : exp '@' exp
- { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
+ { pstate->wrap2<repeat_operation> (); }
;

exp : exp '*' exp
- { write_exp_elt_opcode (pstate, BINOP_MUL); }
+ { pstate->wrap2<mul_operation> (); }
;

exp : exp '/' exp
- { 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 '=' exp
- { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
+ { pstate->wrap2<equal_operation> (); }
;

exp : exp NOTEQUAL exp
- { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
+ { pstate->wrap2<notequal_operation> (); }
| exp '#' exp
- { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
+ { pstate->wrap2<notequal_operation> (); }
;

exp : exp LEQ exp
- { write_exp_elt_opcode (pstate, BINOP_LEQ); }
+ { pstate->wrap2<leq_operation> (); }
;

exp : exp GEQ exp
- { write_exp_elt_opcode (pstate, BINOP_GEQ); }
+ { pstate->wrap2<geq_operation> (); }
;

exp : exp '<' exp
- { write_exp_elt_opcode (pstate, BINOP_LESS); }
+ { pstate->wrap2<less_operation> (); }
;

exp : exp '>' exp
- { write_exp_elt_opcode (pstate, BINOP_GTR); }
+ { pstate->wrap2<gtr_operation> (); }
;

exp : exp LOGICAL_AND exp
- { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
+ { pstate->wrap2<logical_and_operation> (); }
;

exp : exp OROR exp
- { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
+ { pstate->wrap2<logical_or_operation> (); }
;

exp : exp ASSIGN exp
- { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
+ { pstate->wrap2<assign_operation> (); }
;

/* Constants */

exp : M2_TRUE
- { write_exp_elt_opcode (pstate, OP_BOOL);
- write_exp_elt_longcst (pstate, (LONGEST) $1);
- write_exp_elt_opcode (pstate, OP_BOOL); }
+ { pstate->push_new<bool_operation> ($1); }
;

exp : M2_FALSE
- { write_exp_elt_opcode (pstate, OP_BOOL);
- write_exp_elt_longcst (pstate, (LONGEST) $1);
- write_exp_elt_opcode (pstate, OP_BOOL); }
+ { pstate->push_new<bool_operation> ($1); }
;

exp : INT
- { write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate,
- parse_m2_type (pstate)->builtin_int);
- write_exp_elt_longcst (pstate, (LONGEST) $1);
- write_exp_elt_opcode (pstate, OP_LONG); }
+ {
+ pstate->push_new<long_const_operation>
+ (parse_m2_type (pstate)->builtin_int, $1);
+ }
;

exp : UINT
{
- write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate,
- parse_m2_type (pstate)
- ->builtin_card);
- write_exp_elt_longcst (pstate, (LONGEST) $1);
- write_exp_elt_opcode (pstate, OP_LONG);
+ pstate->push_new<long_const_operation>
+ (parse_m2_type (pstate)->builtin_card, $1);
}
;

exp : CHAR
- { write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate,
- parse_m2_type (pstate)
- ->builtin_char);
- write_exp_elt_longcst (pstate, (LONGEST) $1);
- write_exp_elt_opcode (pstate, OP_LONG); }
+ {
+ pstate->push_new<long_const_operation>
+ (parse_m2_type (pstate)->builtin_char, $1);
+ }
;

exp : FLOAT
- { write_exp_elt_opcode (pstate, OP_FLOAT);
- write_exp_elt_type (pstate,
- parse_m2_type (pstate)
- ->builtin_real);
- write_exp_elt_floatcst (pstate, $1);
- write_exp_elt_opcode (pstate, OP_FLOAT); }
+ {
+ float_data data;
+ std::copy (std::begin ($1), std::end ($1),
+ std::begin (data));
+ pstate->push_new<float_const_operation>
+ (parse_m2_type (pstate)->builtin_real, data);
+ }
;

exp : variable
;

exp : SIZE '(' type ')' %prec UNARY
- { write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate,
- parse_type (pstate)->builtin_int);
- write_exp_elt_longcst (pstate,
- (LONGEST) TYPE_LENGTH ($3));
- write_exp_elt_opcode (pstate, OP_LONG); }
+ {
+ pstate->push_new<long_const_operation>
+ (parse_m2_type (pstate)->builtin_int,
+ TYPE_LENGTH ($3));
+ }
;

exp : STRING
- { write_exp_elt_opcode (pstate, OP_M2_STRING);
- write_exp_string (pstate, $1);
- write_exp_elt_opcode (pstate, OP_M2_STRING); }
+ { error (_("strings are not implemented")); }
;

/* This will be used for extensions later. Like adding modules. */
@@ -527,15 +516,15 @@ fblock : block COLONCOLON BLOCKNAME

/* Useful for assigning to PROCEDURE variables */
variable: fblock
- { write_exp_elt_opcode (pstate, OP_VAR_VALUE);
- write_exp_elt_block (pstate, NULL);
- write_exp_elt_sym (pstate, $1);
- write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
+ {
+ pstate->push_new<var_value_operation>
+ ($1, nullptr);
+ }
;

/* GDB internal ($foo) variable */
variable: DOLLAR_VARIABLE
- { write_dollar_variable (pstate, $1); }
+ { pstate->push_dollar ($1); }
;

/* GDB scope operator */
@@ -550,10 +539,9 @@ variable: block COLONCOLON NAME
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);
+ }
;

/* Base case for variables. */
@@ -568,8 +556,7 @@ variable: NAME
VAR_DOMAIN,
&is_a_field_of_this);

- write_exp_symbol_reference (pstate, name.c_str (),
- sym.symbol);
+ pstate->push_symbol (name.c_str (), sym.symbol);
}
;

@@ -1015,7 +1002,10 @@ m2_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