| /* YACC grammar for Modula-2 expressions, for GDB. | |
| Copyright (C) 1986-2026 Free Software Foundation, Inc. | |
| Generated from expread.y (now c-exp-parser.y) and contributed by the Department | |
| of Computer Science at the State University of New York at Buffalo, 1991. | |
| This file is part of GDB. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 3 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
| /* Parse a Modula-2 expression from text in a string, | |
| and return the result as a struct expression pointer. | |
| That structure contains arithmetic operations in reverse polish, | |
| with constants represented by operations that are followed by special data. | |
| See expression.h for the details of the format. | |
| What is important here is that it can be built up sequentially | |
| during the process of parsing; the lower levels of the tree always | |
| come first in the result. | |
| Note that malloc's and realloc's in this file are transformed to | |
| xmalloc and xrealloc respectively by the same sed command in the | |
| makefile that remaps any other malloc/realloc inserted by the parser | |
| generator. Doing this with #defines and trying to control the interaction | |
| with include files (<malloc.h> and <stdlib.h> for example) just became | |
| too messy, particularly when such includes can be inserted at random | |
| times by the parser generator. */ | |
| %{ | |
| #include "expression.h" | |
| #include "language.h" | |
| #include "value.h" | |
| #include "parser-defs.h" | |
| #include "m2-lang.h" | |
| #include "m2-exp-parser.h" | |
| #include "block.h" | |
| #include "m2-exp.h" | |
| using namespace m2_exp_parser; | |
| using namespace expr; | |
| %} | |
| /* Although the yacc "value" of an expression is not used, | |
| since the result is stored in the structure being created, | |
| other node types do have values. */ | |
| %union | |
| { | |
| LONGEST lval; | |
| ULONGEST ulval; | |
| gdb_byte val[16]; | |
| struct symbol *sym; | |
| struct type *tval; | |
| struct stoken sval; | |
| int voidval; | |
| const struct block *bval; | |
| enum exp_opcode opcode; | |
| struct internalvar *ivar; | |
| struct type **tvec; | |
| int *ivec; | |
| } | |
| %type <voidval> exp type_exp start set | |
| %type <voidval> variable | |
| %type <tval> type | |
| %type <bval> block | |
| %type <sym> fblock | |
| %token <lval> INT HEX ERROR | |
| %token <ulval> UINT M2_TRUE M2_FALSE CHAR | |
| %token <val> FLOAT | |
| /* Both NAME and TYPENAME tokens represent symbols in the input, | |
| and both convey their data as strings. | |
| But a TYPENAME is a string that happens to be defined as a typedef | |
| or builtin type name (such as int or char) | |
| and a NAME is any other symbol. | |
| Contexts where this distinction is not important can use the | |
| nonterminal "name", which matches either NAME or TYPENAME. */ | |
| %token <sval> STRING | |
| %token <sval> NAME BLOCKNAME IDENT VARNAME | |
| %token <sval> TYPENAME | |
| %token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC | |
| %token TSIZE ADR | |
| %token INC DEC INCL EXCL | |
| /* The GDB scope operator */ | |
| %token COLONCOLON | |
| %token <sval> DOLLAR_VARIABLE | |
| /* M2 tokens */ | |
| %left ',' | |
| %left ABOVE_COMMA | |
| %nonassoc ASSIGN | |
| %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN | |
| %left OROR | |
| %left LOGICAL_AND '&' | |
| %left '@' | |
| %left '+' '-' | |
| %left '*' '/' DIV MOD | |
| %right UNARY | |
| %right '^' DOT '[' '(' | |
| %right NOT '~' | |
| %left COLONCOLON QID | |
| /* This is not an actual token ; it is used for precedence. | |
| %right QID | |
| */ | |
| %% | |
| start : exp | |
| | type_exp | |
| ; | |
| type_exp: type | |
| { pstate->push_new<type_operation> ($1); } | |
| ; | |
| /* Expressions */ | |
| exp : exp '^' %prec UNARY | |
| { pstate->wrap<unop_ind_operation> (); } | |
| ; | |
| exp : '-' | |
| { number_sign = -1; } | |
| exp %prec UNARY | |
| { number_sign = 1; | |
| pstate->wrap<unary_neg_operation> (); } | |
| ; | |
| exp : '+' exp %prec UNARY | |
| { pstate->wrap<unary_plus_operation> (); } | |
| ; | |
| exp : not_exp exp %prec UNARY | |
| { pstate->wrap<unary_logical_not_operation> (); } | |
| ; | |
| not_exp : NOT | |
| | '~' | |
| ; | |
| exp : CAP '(' exp ')' | |
| { error (_("CAP function is not implemented")); } | |
| ; | |
| exp : ORD '(' exp ')' | |
| { error (_("ORD function is not implemented")); } | |
| ; | |
| exp : ABS '(' exp ')' | |
| { error (_("ABS function is not implemented")); } | |
| ; | |
| exp : ADR '(' exp ')' | |
| { pstate->wrap<unop_addr_operation> (); } | |
| ; | |
| exp : HIGH '(' exp ')' | |
| { pstate->wrap<m2_unop_high_operation> (); } | |
| ; | |
| exp : MIN_FUNC '(' type ')' | |
| { error (_("MIN function is not implemented")); } | |
| ; | |
| exp : MAX_FUNC '(' type ')' | |
| { error (_("MAX function is not implemented")); } | |
| ; | |
| exp : FLOAT_FUNC '(' exp ')' | |
| { error (_("FLOAT function is not implemented")); } | |
| ; | |
| exp : VAL '(' type ',' exp ')' | |
| { error (_("VAL function is not implemented")); } | |
| ; | |
| exp : CHR '(' exp ')' | |
| { error (_("CHR function is not implemented")); } | |
| ; | |
| exp : ODD '(' exp ')' | |
| { error (_("ODD function is not implemented")); } | |
| ; | |
| exp : TRUNC '(' exp ')' | |
| { error (_("TRUNC function is not implemented")); } | |
| ; | |
| exp : TSIZE '(' exp ')' | |
| { pstate->wrap<unop_sizeof_operation> (); } | |
| ; | |
| exp : SIZE exp %prec UNARY | |
| { pstate->wrap<unop_sizeof_operation> (); } | |
| ; | |
| exp : INC '(' exp ')' | |
| { pstate->wrap<preinc_operation> (); } | |
| ; | |
| exp : INC '(' exp ',' exp ')' | |
| { | |
| 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 ')' | |
| { pstate->wrap<predec_operation> (); } | |
| ; | |
| exp : DEC '(' exp ',' exp ')' | |
| { | |
| 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 | |
| { | |
| pstate->push_new<structop_operation> | |
| (pstate->pop (), copy_name ($3)); | |
| } | |
| ; | |
| exp : set | |
| ; | |
| exp : exp IN set | |
| { error (_("Sets are not implemented."));} | |
| ; | |
| exp : INCL '(' exp ',' exp ')' | |
| { error (_("Sets are not implemented."));} | |
| ; | |
| exp : EXCL '(' exp ',' exp ')' | |
| { error (_("Sets are not implemented."));} | |
| ; | |
| set : '{' arglist '}' | |
| { error (_("Sets are not implemented."));} | |
| | type '{' arglist '}' | |
| { error (_("Sets are not implemented."));} | |
| ; | |
| /* Modula-2 array subscript notation [a,b,c...]. */ | |
| exp : exp '[' | |
| /* This function just saves the number of arguments | |
| that follow in the list. It is *not* specific to | |
| function types */ | |
| { pstate->start_arglist(); } | |
| non_empty_arglist ']' %prec DOT | |
| { | |
| gdb_assert (pstate->arglist_len > 0); | |
| std::vector<operation_up> args | |
| = pstate->pop_vector (pstate->end_arglist ()); | |
| pstate->push_new<multi_subscript_operation> | |
| (pstate->pop (), std::move (args)); | |
| } | |
| ; | |
| exp : exp '(' | |
| /* This is to save the value of arglist_len | |
| being accumulated by an outer function call. */ | |
| { pstate->start_arglist (); } | |
| arglist ')' %prec DOT | |
| { | |
| std::vector<operation_up> args | |
| = pstate->pop_vector (pstate->end_arglist ()); | |
| pstate->push_new<funcall_operation> | |
| (pstate->pop (), std::move (args)); | |
| } | |
| ; | |
| arglist : | |
| ; | |
| arglist : exp | |
| { pstate->arglist_len = 1; } | |
| ; | |
| arglist : arglist ',' exp %prec ABOVE_COMMA | |
| { pstate->arglist_len++; } | |
| ; | |
| non_empty_arglist | |
| : exp | |
| { pstate->arglist_len = 1; } | |
| ; | |
| non_empty_arglist | |
| : non_empty_arglist ',' exp %prec ABOVE_COMMA | |
| { pstate->arglist_len++; } | |
| ; | |
| /* GDB construct */ | |
| exp : '{' type '}' exp %prec UNARY | |
| { | |
| pstate->push_new<unop_memval_operation> | |
| (pstate->pop (), $2); | |
| } | |
| ; | |
| exp : type '(' exp ')' %prec UNARY | |
| { | |
| pstate->push_new<unop_cast_operation> | |
| (pstate->pop (), $1); | |
| } | |
| ; | |
| exp : '(' exp ')' | |
| { } | |
| ; | |
| /* Binary operators in order of decreasing precedence. Note that some | |
| of these operators are overloaded! (ie. sets) */ | |
| /* GDB construct */ | |
| exp : exp '@' exp | |
| { pstate->wrap2<repeat_operation> (); } | |
| ; | |
| exp : exp '*' exp | |
| { pstate->wrap2<mul_operation> (); } | |
| ; | |
| exp : exp '/' exp | |
| { pstate->wrap2<div_operation> (); } | |
| ; | |
| exp : exp DIV exp | |
| { pstate->wrap2<intdiv_operation> (); } | |
| ; | |
| exp : exp MOD exp | |
| { pstate->wrap2<rem_operation> (); } | |
| ; | |
| exp : exp '+' exp | |
| { pstate->wrap2<add_operation> (); } | |
| ; | |
| exp : exp '-' exp | |
| { pstate->wrap2<sub_operation> (); } | |
| ; | |
| exp : exp '=' exp | |
| { pstate->wrap2<equal_operation> (); } | |
| ; | |
| exp : exp NOTEQUAL exp | |
| { pstate->wrap2<notequal_operation> (); } | |
| | exp '#' exp | |
| { pstate->wrap2<notequal_operation> (); } | |
| ; | |
| exp : exp LEQ exp | |
| { pstate->wrap2<leq_operation> (); } | |
| ; | |
| exp : exp GEQ exp | |
| { pstate->wrap2<geq_operation> (); } | |
| ; | |
| exp : exp '<' exp | |
| { pstate->wrap2<less_operation> (); } | |
| ; | |
| exp : exp '>' exp | |
| { pstate->wrap2<gtr_operation> (); } | |
| ; | |
| exp : exp LOGICAL_AND exp | |
| { pstate->wrap2<logical_and_operation> (); } | |
| ; | |
| exp : exp OROR exp | |
| { pstate->wrap2<logical_or_operation> (); } | |
| ; | |
| exp : exp ASSIGN exp | |
| { pstate->wrap2<assign_operation> (); } | |
| ; | |
| /* Constants */ | |
| exp : M2_TRUE | |
| { pstate->push_new<bool_operation> ($1); } | |
| ; | |
| exp : M2_FALSE | |
| { pstate->push_new<bool_operation> ($1); } | |
| ; | |
| exp : INT | |
| { | |
| pstate->push_new<long_const_operation> | |
| (parse_m2_type (pstate)->builtin_int, $1); | |
| } | |
| ; | |
| exp : UINT | |
| { | |
| pstate->push_new<long_const_operation> | |
| (parse_m2_type (pstate)->builtin_card, $1); | |
| } | |
| ; | |
| exp : CHAR | |
| { | |
| pstate->push_new<long_const_operation> | |
| (parse_m2_type (pstate)->builtin_char, $1); | |
| } | |
| ; | |
| exp : 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 | |
| { | |
| pstate->push_new<long_const_operation> | |
| (parse_m2_type (pstate)->builtin_int, | |
| $3->length ()); | |
| } | |
| ; | |
| exp : STRING | |
| { error (_("strings are not implemented")); } | |
| ; | |
| /* This will be used for extensions later. Like adding modules. */ | |
| block : fblock | |
| { $$ = $1->value_block (); } | |
| ; | |
| fblock : BLOCKNAME | |
| { struct symbol *sym | |
| = lookup_symbol (copy_name ($1).c_str (), | |
| pstate->expression_context_block, | |
| SEARCH_VFT, 0).symbol; | |
| $$ = sym;} | |
| ; | |
| /* GDB scope operator */ | |
| fblock : block COLONCOLON BLOCKNAME | |
| { struct symbol *tem | |
| = lookup_symbol (copy_name ($3).c_str (), $1, | |
| SEARCH_VFT, 0).symbol; | |
| if (!tem || tem->loc_class () != LOC_BLOCK) | |
| error (_("No function \"%s\" in specified context."), | |
| copy_name ($3).c_str ()); | |
| $$ = tem; | |
| } | |
| ; | |
| /* Useful for assigning to PROCEDURE variables */ | |
| variable: fblock | |
| { | |
| block_symbol sym { $1, nullptr }; | |
| pstate->push_new<var_value_operation> (sym); | |
| } | |
| ; | |
| /* GDB internal ($foo) variable */ | |
| variable: DOLLAR_VARIABLE | |
| { pstate->push_dollar ($1); } | |
| ; | |
| /* GDB scope operator */ | |
| variable: block COLONCOLON NAME | |
| { struct block_symbol sym | |
| = lookup_symbol (copy_name ($3).c_str (), $1, | |
| SEARCH_VFT, 0); | |
| if (sym.symbol == 0) | |
| error (_("No symbol \"%s\" in specified context."), | |
| copy_name ($3).c_str ()); | |
| if (symbol_read_needs_frame (sym.symbol)) | |
| pstate->block_tracker->update (sym); | |
| pstate->push_new<var_value_operation> (sym); | |
| } | |
| ; | |
| /* Base case for variables. */ | |
| variable: NAME | |
| { struct block_symbol sym; | |
| struct field_of_this_result is_a_field_of_this; | |
| std::string name = copy_name ($1); | |
| sym | |
| = lookup_symbol (name.c_str (), | |
| pstate->expression_context_block, | |
| SEARCH_VFT, | |
| &is_a_field_of_this); | |
| pstate->push_symbol (name.c_str (), sym); | |
| } | |
| ; | |
| type | |
| : TYPENAME | |
| { $$ | |
| = lookup_typename (pstate->language (), | |
| copy_name ($1).c_str (), | |
| pstate->expression_context_block, | |
| false); | |
| } | |
| ; |