Convert m2-exp.y to use operations
authorTom Tromey <tom@tromey.com>
Mon, 8 Mar 2021 14:27:57 +0000 (07:27 -0700)
committerTom Tromey <tom@tromey.com>
Mon, 8 Mar 2021 14:28:39 +0000 (07:28 -0700)
This converts the Modula-2 parser to generate operations rather than
exp_elements.

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

* m2-exp.y: Create operations.
(m2_language::parser): Update.

gdb/ChangeLog
gdb/m2-exp.y

index 5852e58598993a2018b1e6d7c04f0e47e1acb81f..7834e755e70e7c6431bcefdcdd3f5e940b8e0ccf 100644 (file)
@@ -1,3 +1,8 @@
+2021-03-08  Tom Tromey  <tom@tromey.com>
+
+       * m2-exp.y: Create operations.
+       (m2_language::parser): Update.
+
 2021-03-08  Tom Tromey  <tom@tromey.com>
 
        * p-exp.y: Create operations.
index 68bae48feb6b446180ded985b7258e0608aa9ebc..273270a85ce2694ce1477e43540841cc8f18598c 100644 (file)
@@ -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);
+                         pstate->push_symbol (name.c_str (), sym);
                        }
        ;
 
@@ -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