1 /* YACC grammar for Modula-2 expressions, for GDB.
2 Copyright (C) 1986-2021 Free Software Foundation, Inc.
3 Generated from expread.y (now c-exp.y) and contributed by the Department
4 of Computer Science at the State University of New York at Buffalo, 1991.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Parse a Modula-2 expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
41 #include "expression.h"
44 #include "parser-defs.h"
46 #include "bfd.h" /* Required by objfiles.h. */
47 #include "symfile.h" /* Required by objfiles.h. */
48 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
51 #define parse_type(ps) builtin_type (ps->gdbarch ())
52 #define parse_m2_type(ps) builtin_m2_type (ps->gdbarch ())
54 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
56 #define GDB_YY_REMAP_PREFIX m2_
59 /* The state of the parser, used internally when we are parsing the
62 static struct parser_state *pstate = NULL;
66 static int yylex (void);
68 static void yyerror (const char *);
70 static int parse_number (int);
72 /* The sign of the number being parsed. */
73 static int number_sign = 1;
77 /* Although the yacc "value" of an expression is not used,
78 since the result is stored in the structure being created,
79 other node types do have values. */
90 const struct block *bval;
91 enum exp_opcode opcode;
92 struct internalvar *ivar;
98 %type <voidval> exp type_exp start set
99 %type <voidval> variable
104 %token <lval> INT HEX ERROR
105 %token <ulval> UINT M2_TRUE M2_FALSE CHAR
108 /* Both NAME and TYPENAME tokens represent symbols in the input,
109 and both convey their data as strings.
110 But a TYPENAME is a string that happens to be defined as a typedef
111 or builtin type name (such as int or char)
112 and a NAME is any other symbol.
114 Contexts where this distinction is not important can use the
115 nonterminal "name", which matches either NAME or TYPENAME. */
118 %token <sval> NAME BLOCKNAME IDENT VARNAME
119 %token <sval> TYPENAME
121 %token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
123 %token INC DEC INCL EXCL
125 /* The GDB scope operator */
128 %token <sval> DOLLAR_VARIABLE
134 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
136 %left LOGICAL_AND '&'
139 %left '*' '/' DIV MOD
141 %right '^' DOT '[' '('
144 /* This is not an actual token ; it is used for precedence.
156 { write_exp_elt_opcode (pstate, OP_TYPE);
157 write_exp_elt_type (pstate, $1);
158 write_exp_elt_opcode (pstate, OP_TYPE);
164 exp : exp '^' %prec UNARY
165 { write_exp_elt_opcode (pstate, UNOP_IND); }
169 { number_sign = -1; }
172 write_exp_elt_opcode (pstate, UNOP_NEG); }
175 exp : '+' exp %prec UNARY
176 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
179 exp : not_exp exp %prec UNARY
180 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
187 exp : CAP '(' exp ')'
188 { write_exp_elt_opcode (pstate, UNOP_CAP); }
191 exp : ORD '(' exp ')'
192 { write_exp_elt_opcode (pstate, UNOP_ORD); }
195 exp : ABS '(' exp ')'
196 { write_exp_elt_opcode (pstate, UNOP_ABS); }
199 exp : HIGH '(' exp ')'
200 { write_exp_elt_opcode (pstate, UNOP_HIGH); }
203 exp : MIN_FUNC '(' type ')'
204 { write_exp_elt_opcode (pstate, UNOP_MIN);
205 write_exp_elt_type (pstate, $3);
206 write_exp_elt_opcode (pstate, UNOP_MIN); }
209 exp : MAX_FUNC '(' type ')'
210 { write_exp_elt_opcode (pstate, UNOP_MAX);
211 write_exp_elt_type (pstate, $3);
212 write_exp_elt_opcode (pstate, UNOP_MAX); }
215 exp : FLOAT_FUNC '(' exp ')'
216 { write_exp_elt_opcode (pstate, UNOP_FLOAT); }
219 exp : VAL '(' type ',' exp ')'
220 { write_exp_elt_opcode (pstate, BINOP_VAL);
221 write_exp_elt_type (pstate, $3);
222 write_exp_elt_opcode (pstate, BINOP_VAL); }
225 exp : CHR '(' exp ')'
226 { write_exp_elt_opcode (pstate, UNOP_CHR); }
229 exp : ODD '(' exp ')'
230 { write_exp_elt_opcode (pstate, UNOP_ODD); }
233 exp : TRUNC '(' exp ')'
234 { write_exp_elt_opcode (pstate, UNOP_TRUNC); }
237 exp : TSIZE '(' exp ')'
238 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
241 exp : SIZE exp %prec UNARY
242 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
246 exp : INC '(' exp ')'
247 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
250 exp : INC '(' exp ',' exp ')'
251 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
252 write_exp_elt_opcode (pstate, BINOP_ADD);
253 write_exp_elt_opcode (pstate,
254 BINOP_ASSIGN_MODIFY); }
257 exp : DEC '(' exp ')'
258 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT);}
261 exp : DEC '(' exp ',' exp ')'
262 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
263 write_exp_elt_opcode (pstate, BINOP_SUB);
264 write_exp_elt_opcode (pstate,
265 BINOP_ASSIGN_MODIFY); }
269 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
270 write_exp_string (pstate, $3);
271 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
278 { error (_("Sets are not implemented."));}
281 exp : INCL '(' exp ',' exp ')'
282 { error (_("Sets are not implemented."));}
285 exp : EXCL '(' exp ',' exp ')'
286 { error (_("Sets are not implemented."));}
289 set : '{' arglist '}'
290 { error (_("Sets are not implemented."));}
291 | type '{' arglist '}'
292 { error (_("Sets are not implemented."));}
296 /* Modula-2 array subscript notation [a,b,c...]. */
298 /* This function just saves the number of arguments
299 that follow in the list. It is *not* specific to
301 { pstate->start_arglist(); }
302 non_empty_arglist ']' %prec DOT
304 gdb_assert (pstate->arglist_len > 0);
305 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
306 write_exp_elt_longcst (pstate,
307 pstate->end_arglist());
308 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
313 /* This is to save the value of arglist_len
314 being accumulated by an outer function call. */
315 { pstate->start_arglist (); }
316 arglist ')' %prec DOT
317 { write_exp_elt_opcode (pstate, OP_FUNCALL);
318 write_exp_elt_longcst (pstate,
319 pstate->end_arglist ());
320 write_exp_elt_opcode (pstate, OP_FUNCALL); }
327 { pstate->arglist_len = 1; }
330 arglist : arglist ',' exp %prec ABOVE_COMMA
331 { pstate->arglist_len++; }
336 { pstate->arglist_len = 1; }
340 : non_empty_arglist ',' exp %prec ABOVE_COMMA
341 { pstate->arglist_len++; }
345 exp : '{' type '}' exp %prec UNARY
346 { write_exp_elt_opcode (pstate, UNOP_MEMVAL);
347 write_exp_elt_type (pstate, $2);
348 write_exp_elt_opcode (pstate, UNOP_MEMVAL); }
351 exp : type '(' exp ')' %prec UNARY
352 { write_exp_elt_opcode (pstate, UNOP_CAST);
353 write_exp_elt_type (pstate, $1);
354 write_exp_elt_opcode (pstate, UNOP_CAST); }
361 /* Binary operators in order of decreasing precedence. Note that some
362 of these operators are overloaded! (ie. sets) */
366 { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
370 { write_exp_elt_opcode (pstate, BINOP_MUL); }
374 { write_exp_elt_opcode (pstate, BINOP_DIV); }
378 { write_exp_elt_opcode (pstate, BINOP_INTDIV); }
382 { write_exp_elt_opcode (pstate, BINOP_REM); }
386 { write_exp_elt_opcode (pstate, BINOP_ADD); }
390 { write_exp_elt_opcode (pstate, BINOP_SUB); }
394 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
397 exp : exp NOTEQUAL exp
398 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
400 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
404 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
408 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
412 { write_exp_elt_opcode (pstate, BINOP_LESS); }
416 { write_exp_elt_opcode (pstate, BINOP_GTR); }
419 exp : exp LOGICAL_AND exp
420 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
424 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
428 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
435 { write_exp_elt_opcode (pstate, OP_BOOL);
436 write_exp_elt_longcst (pstate, (LONGEST) $1);
437 write_exp_elt_opcode (pstate, OP_BOOL); }
441 { write_exp_elt_opcode (pstate, OP_BOOL);
442 write_exp_elt_longcst (pstate, (LONGEST) $1);
443 write_exp_elt_opcode (pstate, OP_BOOL); }
447 { write_exp_elt_opcode (pstate, OP_LONG);
448 write_exp_elt_type (pstate,
449 parse_m2_type (pstate)->builtin_int);
450 write_exp_elt_longcst (pstate, (LONGEST) $1);
451 write_exp_elt_opcode (pstate, OP_LONG); }
456 write_exp_elt_opcode (pstate, OP_LONG);
457 write_exp_elt_type (pstate,
458 parse_m2_type (pstate)
460 write_exp_elt_longcst (pstate, (LONGEST) $1);
461 write_exp_elt_opcode (pstate, OP_LONG);
466 { write_exp_elt_opcode (pstate, OP_LONG);
467 write_exp_elt_type (pstate,
468 parse_m2_type (pstate)
470 write_exp_elt_longcst (pstate, (LONGEST) $1);
471 write_exp_elt_opcode (pstate, OP_LONG); }
476 { write_exp_elt_opcode (pstate, OP_FLOAT);
477 write_exp_elt_type (pstate,
478 parse_m2_type (pstate)
480 write_exp_elt_floatcst (pstate, $1);
481 write_exp_elt_opcode (pstate, OP_FLOAT); }
487 exp : SIZE '(' type ')' %prec UNARY
488 { write_exp_elt_opcode (pstate, OP_LONG);
489 write_exp_elt_type (pstate,
490 parse_type (pstate)->builtin_int);
491 write_exp_elt_longcst (pstate,
492 (LONGEST) TYPE_LENGTH ($3));
493 write_exp_elt_opcode (pstate, OP_LONG); }
497 { write_exp_elt_opcode (pstate, OP_M2_STRING);
498 write_exp_string (pstate, $1);
499 write_exp_elt_opcode (pstate, OP_M2_STRING); }
502 /* This will be used for extensions later. Like adding modules. */
504 { $$ = SYMBOL_BLOCK_VALUE($1); }
509 = lookup_symbol (copy_name ($1).c_str (),
510 pstate->expression_context_block,
511 VAR_DOMAIN, 0).symbol;
516 /* GDB scope operator */
517 fblock : block COLONCOLON BLOCKNAME
519 = lookup_symbol (copy_name ($3).c_str (), $1,
520 VAR_DOMAIN, 0).symbol;
521 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
522 error (_("No function \"%s\" in specified context."),
523 copy_name ($3).c_str ());
528 /* Useful for assigning to PROCEDURE variables */
530 { write_exp_elt_opcode (pstate, OP_VAR_VALUE);
531 write_exp_elt_block (pstate, NULL);
532 write_exp_elt_sym (pstate, $1);
533 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
536 /* GDB internal ($foo) variable */
537 variable: DOLLAR_VARIABLE
538 { write_dollar_variable (pstate, $1); }
541 /* GDB scope operator */
542 variable: block COLONCOLON NAME
543 { struct block_symbol sym
544 = lookup_symbol (copy_name ($3).c_str (), $1,
548 error (_("No symbol \"%s\" in specified context."),
549 copy_name ($3).c_str ());
550 if (symbol_read_needs_frame (sym.symbol))
551 pstate->block_tracker->update (sym);
553 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
554 write_exp_elt_block (pstate, sym.block);
555 write_exp_elt_sym (pstate, sym.symbol);
556 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
559 /* Base case for variables. */
561 { struct block_symbol sym;
562 struct field_of_this_result is_a_field_of_this;
564 std::string name = copy_name ($1);
566 = lookup_symbol (name.c_str (),
567 pstate->expression_context_block,
569 &is_a_field_of_this);
571 write_exp_symbol_reference (pstate, name.c_str (),
579 = lookup_typename (pstate->language (),
580 copy_name ($1).c_str (),
581 pstate->expression_context_block,
589 /* Take care of parsing a number (anything that starts with a digit).
590 Set yylval and return the token type; update lexptr.
591 LEN is the number of characters in it. */
593 /*** Needs some error checking for the float case ***/
596 parse_number (int olen)
598 const char *p = pstate->lexptr;
602 int base = input_radix;
604 int unsigned_p = number_sign == 1 ? 1 : 0;
611 else if(p[len-1] == 'C' || p[len-1] == 'B')
614 ischar = p[len-1] == 'C';
618 /* Scan the number */
619 for (c = 0; c < len; c++)
621 if (p[c] == '.' && base == 10)
623 /* It's a float since it contains a point. */
624 if (!parse_float (p, len,
625 parse_m2_type (pstate)->builtin_real,
629 pstate->lexptr += len;
632 if (p[c] == '.' && base != 10)
633 error (_("Floating point numbers must be base 10."));
634 if (base == 10 && (p[c] < '0' || p[c] > '9'))
635 error (_("Invalid digit \'%c\' in number."),p[c]);
642 if( base == 8 && (c == '8' || c == '9'))
643 error (_("Invalid digit \'%c\' in octal number."),c);
644 if (c >= '0' && c <= '9')
648 if (base == 16 && c >= 'A' && c <= 'F')
656 if(!unsigned_p && number_sign == 1 && (prevn >= n))
657 unsigned_p=1; /* Try something unsigned */
658 /* Don't do the range check if n==i and i==0, since that special
659 case will give an overflow error. */
660 if(RANGE_CHECK && n!=i && i)
662 if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
663 ((!unsigned_p && number_sign==-1) && -prevn <= -n))
664 range_error (_("Overflow on numeric constant."));
670 if(*p == 'B' || *p == 'C' || *p == 'H')
671 pstate->lexptr++; /* Advance past B,C or H */
678 else if ( unsigned_p && number_sign == 1)
683 else if((unsigned_p && (n<0))) {
684 range_error (_("Overflow on numeric constant -- number too large."));
685 /* But, this can return if range_check == range_warn. */
700 { {'<', '>'}, NOTEQUAL },
701 { {':', '='}, ASSIGN },
704 { {':', ':'}, COLONCOLON },
708 /* Some specific keywords */
715 static struct keyword keytab[] =
718 {"IN", IN },/* Note space after IN */
719 {"AND", LOGICAL_AND},
737 {"FLOAT", FLOAT_FUNC },
743 /* Depth of parentheses. */
744 static int paren_depth;
746 /* Read one token, getting characters through lexptr. */
748 /* This is where we will check to make sure that the language and the
749 operators used are compatible */
757 const char *tokstart;
762 pstate->prev_lexptr = pstate->lexptr;
764 tokstart = pstate->lexptr;
767 /* See if it is a special token of length 2 */
768 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
769 if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
772 return tokentab2[i].token;
775 switch (c = *tokstart)
792 if (paren_depth == 0)
799 if (pstate->comma_terminates && paren_depth == 0)
805 /* Might be a floating point number. */
806 if (pstate->lexptr[1] >= '0' && pstate->lexptr[1] <= '9')
807 break; /* Falls into number code. */
814 /* These are character tokens that appear as-is in the YACC grammar */
837 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
840 c = tokstart[++namelen];
841 if (c >= '0' && c <= '9')
843 c = tokstart[++namelen];
844 if (c >= '0' && c <= '9')
845 c = tokstart[++namelen];
849 error (_("Unterminated string or character constant."));
850 yylval.sval.ptr = tokstart + 1;
851 yylval.sval.length = namelen - 1;
852 pstate->lexptr += namelen + 1;
854 if(namelen == 2) /* Single character */
856 yylval.ulval = tokstart[1];
863 /* Is it a number? */
864 /* Note: We have already dealt with the case of the token '.'.
865 See case '.' above. */
866 if ((c >= '0' && c <= '9'))
869 int got_dot = 0, got_e = 0;
870 const char *p = tokstart;
875 if (!got_e && (*p == 'e' || *p == 'E'))
877 else if (!got_dot && *p == '.')
879 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
880 && (*p == '-' || *p == '+'))
881 /* This is the sign of the exponent, not the end of the
884 else if ((*p < '0' || *p > '9') &&
885 (*p < 'A' || *p > 'F') &&
886 (*p != 'H')) /* Modula-2 hexadecimal number */
889 toktype = parse_number (p - tokstart);
890 if (toktype == ERROR)
892 char *err_copy = (char *) alloca (p - tokstart + 1);
894 memcpy (err_copy, tokstart, p - tokstart);
895 err_copy[p - tokstart] = 0;
896 error (_("Invalid number \"%s\"."), err_copy);
902 if (!(c == '_' || c == '$'
903 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
904 /* We must have come across a bad character (e.g. ';'). */
905 error (_("Invalid character '%c' in expression."), c);
907 /* It's a name. See how long it is. */
909 for (c = tokstart[namelen];
910 (c == '_' || c == '$' || (c >= '0' && c <= '9')
911 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
912 c = tokstart[++namelen])
915 /* The token "if" terminates the expression and is NOT
916 removed from the input stream. */
917 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
922 pstate->lexptr += namelen;
924 /* Lookup special keywords */
925 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
926 if (namelen == strlen (keytab[i].keyw)
927 && strncmp (tokstart, keytab[i].keyw, namelen) == 0)
928 return keytab[i].token;
930 yylval.sval.ptr = tokstart;
931 yylval.sval.length = namelen;
933 if (*tokstart == '$')
934 return DOLLAR_VARIABLE;
936 /* Use token-type BLOCKNAME for symbols that happen to be defined as
937 functions. If this is not so, then ...
938 Use token-type TYPENAME for symbols that happen to be defined
939 currently as names of types; NAME for other symbols.
940 The caller is not constrained to care about the distinction. */
942 std::string tmp = copy_name (yylval.sval);
945 if (lookup_symtab (tmp.c_str ()))
947 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
948 VAR_DOMAIN, 0).symbol;
949 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
951 if (lookup_typename (pstate->language (),
952 tmp.c_str (), pstate->expression_context_block, 1))
957 switch(SYMBOL_CLASS (sym))
963 case LOC_REGPARM_ADDR:
966 case LOC_CONST_BYTES:
967 case LOC_OPTIMIZED_OUT:
978 error (_("internal: Undefined class in m2lex()"));
982 error (_("internal: Unforseen case in m2lex()"));
985 error (_("unhandled token in m2lex()"));
991 /* Built-in BOOLEAN type. This is sort of a hack. */
992 if (strncmp (tokstart, "TRUE", 4) == 0)
997 else if (strncmp (tokstart, "FALSE", 5) == 0)
1004 /* Must be another type of name... */
1010 m2_language::parser (struct parser_state *par_state) const
1012 /* Setting up the parser state. */
1013 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1014 gdb_assert (par_state != NULL);
1022 yyerror (const char *msg)
1024 if (pstate->prev_lexptr)
1025 pstate->lexptr = pstate->prev_lexptr;
1027 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);