1 /* YACC grammar for Modula-2 expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999,
3 2000, 2007, 2008 Free Software Foundation, Inc.
4 Generated from expread.y (now c-exp.y) and contributed by the Department
5 of Computer Science at the State University of New York at Buffalo, 1991.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
24 /* Parse a Modula-2 expression from text in a string,
25 and return the result as a struct expression pointer.
26 That structure contains arithmetic operations in reverse polish,
27 with constants represented by operations that are followed by special data.
28 See expression.h for the details of the format.
29 What is important here is that it can be built up sequentially
30 during the process of parsing; the lower levels of the tree always
31 come first in the result.
33 Note that malloc's and realloc's in this file are transformed to
34 xmalloc and xrealloc respectively by the same sed command in the
35 makefile that remaps any other malloc/realloc inserted by the parser
36 generator. Doing this with #defines and trying to control the interaction
37 with include files (<malloc.h> and <stdlib.h> for example) just became
38 too messy, particularly when such includes can be inserted at random
39 times by the parser generator. */
44 #include "gdb_string.h"
45 #include "expression.h"
48 #include "parser-defs.h"
50 #include "bfd.h" /* Required by objfiles.h. */
51 #include "symfile.h" /* Required by objfiles.h. */
52 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
55 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
56 as well as gratuitiously global symbol names, so we can have multiple
57 yacc generated parsers in gdb. Note that these are only the variables
58 produced by yacc. If other parser generators (bison, byacc, etc) produce
59 additional global names that conflict at link time, then those parser
60 generators need to be fixed instead of adding those names to this list. */
62 #define yymaxdepth m2_maxdepth
63 #define yyparse m2_parse
65 #define yyerror m2_error
66 #define yylval m2_lval
67 #define yychar m2_char
68 #define yydebug m2_debug
69 #define yypact m2_pact
76 #define yyexca m2_exca
77 #define yyerrflag m2_errflag
78 #define yynerrs m2_nerrs
83 #define yystate m2_state
88 #define yylloc m2_lloc
89 #define yyreds m2_reds /* With YYDEBUG defined */
90 #define yytoks m2_toks /* With YYDEBUG defined */
91 #define yyname m2_name /* With YYDEBUG defined */
92 #define yyrule m2_rule /* With YYDEBUG defined */
93 #define yylhs m2_yylhs
94 #define yylen m2_yylen
95 #define yydefred m2_yydefred
96 #define yydgoto m2_yydgoto
97 #define yysindex m2_yysindex
98 #define yyrindex m2_yyrindex
99 #define yygindex m2_yygindex
100 #define yytable m2_yytable
101 #define yycheck m2_yycheck
104 #define YYDEBUG 1 /* Default to yydebug support */
107 #define YYFPRINTF parser_fprintf
111 static int yylex (void);
113 void yyerror (char *);
116 static char *make_qualname (char *, char *);
119 static int parse_number (int);
121 /* The sign of the number being parsed. */
122 static int number_sign = 1;
124 /* The block that the module specified by the qualifer on an identifer is
127 static struct block *modblock=0;
132 /* Although the yacc "value" of an expression is not used,
133 since the result is stored in the structure being created,
134 other node types do have values. */
146 enum exp_opcode opcode;
147 struct internalvar *ivar;
153 %type <voidval> exp type_exp start set
154 %type <voidval> variable
159 %token <lval> INT HEX ERROR
160 %token <ulval> UINT M2_TRUE M2_FALSE CHAR
163 /* Both NAME and TYPENAME tokens represent symbols in the input,
164 and both convey their data as strings.
165 But a TYPENAME is a string that happens to be defined as a typedef
166 or builtin type name (such as int or char)
167 and a NAME is any other symbol.
169 Contexts where this distinction is not important can use the
170 nonterminal "name", which matches either NAME or TYPENAME. */
173 %token <sval> NAME BLOCKNAME IDENT VARNAME
174 %token <sval> TYPENAME
176 %token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
178 %token INC DEC INCL EXCL
180 /* The GDB scope operator */
183 %token <voidval> INTERNAL_VAR
189 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
191 %left LOGICAL_AND '&'
194 %left '*' '/' DIV MOD
196 %right '^' DOT '[' '('
199 /* This is not an actual token ; it is used for precedence.
211 { write_exp_elt_opcode(OP_TYPE);
212 write_exp_elt_type($1);
213 write_exp_elt_opcode(OP_TYPE);
219 exp : exp '^' %prec UNARY
220 { write_exp_elt_opcode (UNOP_IND); }
224 { number_sign = -1; }
227 write_exp_elt_opcode (UNOP_NEG); }
230 exp : '+' exp %prec UNARY
231 { write_exp_elt_opcode(UNOP_PLUS); }
234 exp : not_exp exp %prec UNARY
235 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
242 exp : CAP '(' exp ')'
243 { write_exp_elt_opcode (UNOP_CAP); }
246 exp : ORD '(' exp ')'
247 { write_exp_elt_opcode (UNOP_ORD); }
250 exp : ABS '(' exp ')'
251 { write_exp_elt_opcode (UNOP_ABS); }
254 exp : HIGH '(' exp ')'
255 { write_exp_elt_opcode (UNOP_HIGH); }
258 exp : MIN_FUNC '(' type ')'
259 { write_exp_elt_opcode (UNOP_MIN);
260 write_exp_elt_type ($3);
261 write_exp_elt_opcode (UNOP_MIN); }
264 exp : MAX_FUNC '(' type ')'
265 { write_exp_elt_opcode (UNOP_MAX);
266 write_exp_elt_type ($3);
267 write_exp_elt_opcode (UNOP_MIN); }
270 exp : FLOAT_FUNC '(' exp ')'
271 { write_exp_elt_opcode (UNOP_FLOAT); }
274 exp : VAL '(' type ',' exp ')'
275 { write_exp_elt_opcode (BINOP_VAL);
276 write_exp_elt_type ($3);
277 write_exp_elt_opcode (BINOP_VAL); }
280 exp : CHR '(' exp ')'
281 { write_exp_elt_opcode (UNOP_CHR); }
284 exp : ODD '(' exp ')'
285 { write_exp_elt_opcode (UNOP_ODD); }
288 exp : TRUNC '(' exp ')'
289 { write_exp_elt_opcode (UNOP_TRUNC); }
292 exp : TSIZE '(' exp ')'
293 { write_exp_elt_opcode (UNOP_SIZEOF); }
296 exp : SIZE exp %prec UNARY
297 { write_exp_elt_opcode (UNOP_SIZEOF); }
301 exp : INC '(' exp ')'
302 { write_exp_elt_opcode(UNOP_PREINCREMENT); }
305 exp : INC '(' exp ',' exp ')'
306 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
307 write_exp_elt_opcode(BINOP_ADD);
308 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
311 exp : DEC '(' exp ')'
312 { write_exp_elt_opcode(UNOP_PREDECREMENT);}
315 exp : DEC '(' exp ',' exp ')'
316 { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
317 write_exp_elt_opcode(BINOP_SUB);
318 write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
322 { write_exp_elt_opcode (STRUCTOP_STRUCT);
323 write_exp_string ($3);
324 write_exp_elt_opcode (STRUCTOP_STRUCT); }
331 { error("Sets are not implemented.");}
334 exp : INCL '(' exp ',' exp ')'
335 { error("Sets are not implemented.");}
338 exp : EXCL '(' exp ',' exp ')'
339 { error("Sets are not implemented.");}
342 set : '{' arglist '}'
343 { error("Sets are not implemented.");}
344 | type '{' arglist '}'
345 { error("Sets are not implemented.");}
349 /* Modula-2 array subscript notation [a,b,c...] */
351 /* This function just saves the number of arguments
352 that follow in the list. It is *not* specific to
355 non_empty_arglist ']' %prec DOT
356 { write_exp_elt_opcode (MULTI_SUBSCRIPT);
357 write_exp_elt_longcst ((LONGEST) end_arglist());
358 write_exp_elt_opcode (MULTI_SUBSCRIPT); }
361 exp : exp '[' exp ']'
362 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
366 /* This is to save the value of arglist_len
367 being accumulated by an outer function call. */
368 { start_arglist (); }
369 arglist ')' %prec DOT
370 { write_exp_elt_opcode (OP_FUNCALL);
371 write_exp_elt_longcst ((LONGEST) end_arglist ());
372 write_exp_elt_opcode (OP_FUNCALL); }
382 arglist : arglist ',' exp %prec ABOVE_COMMA
392 : non_empty_arglist ',' exp %prec ABOVE_COMMA
397 exp : '{' type '}' exp %prec UNARY
398 { write_exp_elt_opcode (UNOP_MEMVAL);
399 write_exp_elt_type ($2);
400 write_exp_elt_opcode (UNOP_MEMVAL); }
403 exp : type '(' exp ')' %prec UNARY
404 { write_exp_elt_opcode (UNOP_CAST);
405 write_exp_elt_type ($1);
406 write_exp_elt_opcode (UNOP_CAST); }
413 /* Binary operators in order of decreasing precedence. Note that some
414 of these operators are overloaded! (ie. sets) */
418 { write_exp_elt_opcode (BINOP_REPEAT); }
422 { write_exp_elt_opcode (BINOP_MUL); }
426 { write_exp_elt_opcode (BINOP_DIV); }
430 { write_exp_elt_opcode (BINOP_INTDIV); }
434 { write_exp_elt_opcode (BINOP_REM); }
438 { write_exp_elt_opcode (BINOP_ADD); }
442 { write_exp_elt_opcode (BINOP_SUB); }
446 { write_exp_elt_opcode (BINOP_EQUAL); }
449 exp : exp NOTEQUAL exp
450 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
452 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
456 { write_exp_elt_opcode (BINOP_LEQ); }
460 { write_exp_elt_opcode (BINOP_GEQ); }
464 { write_exp_elt_opcode (BINOP_LESS); }
468 { write_exp_elt_opcode (BINOP_GTR); }
471 exp : exp LOGICAL_AND exp
472 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
476 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
480 { write_exp_elt_opcode (BINOP_ASSIGN); }
487 { write_exp_elt_opcode (OP_BOOL);
488 write_exp_elt_longcst ((LONGEST) $1);
489 write_exp_elt_opcode (OP_BOOL); }
493 { write_exp_elt_opcode (OP_BOOL);
494 write_exp_elt_longcst ((LONGEST) $1);
495 write_exp_elt_opcode (OP_BOOL); }
499 { write_exp_elt_opcode (OP_LONG);
500 write_exp_elt_type (builtin_type_m2_int);
501 write_exp_elt_longcst ((LONGEST) $1);
502 write_exp_elt_opcode (OP_LONG); }
507 write_exp_elt_opcode (OP_LONG);
508 write_exp_elt_type (builtin_type_m2_card);
509 write_exp_elt_longcst ((LONGEST) $1);
510 write_exp_elt_opcode (OP_LONG);
515 { write_exp_elt_opcode (OP_LONG);
516 write_exp_elt_type (builtin_type_m2_char);
517 write_exp_elt_longcst ((LONGEST) $1);
518 write_exp_elt_opcode (OP_LONG); }
523 { write_exp_elt_opcode (OP_DOUBLE);
524 write_exp_elt_type (builtin_type_m2_real);
525 write_exp_elt_dblcst ($1);
526 write_exp_elt_opcode (OP_DOUBLE); }
532 exp : SIZE '(' type ')' %prec UNARY
533 { write_exp_elt_opcode (OP_LONG);
534 write_exp_elt_type (builtin_type_int);
535 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
536 write_exp_elt_opcode (OP_LONG); }
540 { write_exp_elt_opcode (OP_M2_STRING);
541 write_exp_string ($1);
542 write_exp_elt_opcode (OP_M2_STRING); }
545 /* This will be used for extensions later. Like adding modules. */
547 { $$ = SYMBOL_BLOCK_VALUE($1); }
552 = lookup_symbol (copy_name ($1), expression_context_block,
558 /* GDB scope operator */
559 fblock : block COLONCOLON BLOCKNAME
561 = lookup_symbol (copy_name ($3), $1,
563 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
564 error ("No function \"%s\" in specified context.",
570 /* Useful for assigning to PROCEDURE variables */
572 { write_exp_elt_opcode(OP_VAR_VALUE);
573 write_exp_elt_block (NULL);
574 write_exp_elt_sym ($1);
575 write_exp_elt_opcode (OP_VAR_VALUE); }
578 /* GDB internal ($foo) variable */
579 variable: INTERNAL_VAR
582 /* GDB scope operator */
583 variable: block COLONCOLON NAME
584 { struct symbol *sym;
585 sym = lookup_symbol (copy_name ($3), $1,
588 error ("No symbol \"%s\" in specified context.",
591 write_exp_elt_opcode (OP_VAR_VALUE);
592 /* block_found is set by lookup_symbol. */
593 write_exp_elt_block (block_found);
594 write_exp_elt_sym (sym);
595 write_exp_elt_opcode (OP_VAR_VALUE); }
598 /* Base case for variables. */
600 { struct symbol *sym;
601 int is_a_field_of_this;
603 sym = lookup_symbol (copy_name ($1),
604 expression_context_block,
606 &is_a_field_of_this);
609 if (symbol_read_needs_frame (sym))
611 if (innermost_block == 0 ||
612 contained_in (block_found,
614 innermost_block = block_found;
617 write_exp_elt_opcode (OP_VAR_VALUE);
618 /* We want to use the selected frame, not
619 another more inner frame which happens to
620 be in the same block. */
621 write_exp_elt_block (NULL);
622 write_exp_elt_sym (sym);
623 write_exp_elt_opcode (OP_VAR_VALUE);
627 struct minimal_symbol *msymbol;
628 char *arg = copy_name ($1);
631 lookup_minimal_symbol (arg, NULL, NULL);
633 write_exp_msymbol (msymbol);
634 else if (!have_full_symbols () && !have_partial_symbols ())
635 error ("No symbol table is loaded. Use the \"symbol-file\" command.");
637 error ("No symbol \"%s\" in current context.",
645 { $$ = lookup_typename (copy_name ($1),
646 expression_context_block, 0); }
657 return (MAX_OF_TYPE(builtin_type_m2_int) - b) < a;
664 return (MAX_OF_TYPE(builtin_type_m2_card) - b) < a;
668 /* Take care of parsing a number (anything that starts with a digit).
669 Set yylval and return the token type; update lexptr.
670 LEN is the number of characters in it. */
672 /*** Needs some error checking for the float case ***/
682 int base = input_radix;
684 int unsigned_p = number_sign == 1 ? 1 : 0;
691 else if(p[len-1] == 'C' || p[len-1] == 'B')
694 ischar = p[len-1] == 'C';
698 /* Scan the number */
699 for (c = 0; c < len; c++)
701 if (p[c] == '.' && base == 10)
703 /* It's a float since it contains a point. */
704 yylval.dval = atof (p);
708 if (p[c] == '.' && base != 10)
709 error("Floating point numbers must be base 10.");
710 if (base == 10 && (p[c] < '0' || p[c] > '9'))
711 error("Invalid digit \'%c\' in number.",p[c]);
718 if( base == 8 && (c == '8' || c == '9'))
719 error("Invalid digit \'%c\' in octal number.",c);
720 if (c >= '0' && c <= '9')
724 if (base == 16 && c >= 'A' && c <= 'F')
732 if(!unsigned_p && number_sign == 1 && (prevn >= n))
733 unsigned_p=1; /* Try something unsigned */
734 /* Don't do the range check if n==i and i==0, since that special
735 case will give an overflow error. */
736 if(RANGE_CHECK && n!=i && i)
738 if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
739 ((!unsigned_p && number_sign==-1) && -prevn <= -n))
740 range_error("Overflow on numeric constant.");
746 if(*p == 'B' || *p == 'C' || *p == 'H')
747 lexptr++; /* Advance past B,C or H */
754 else if ( unsigned_p && number_sign == 1)
759 else if((unsigned_p && (n<0))) {
760 range_error("Overflow on numeric constant -- number too large.");
761 /* But, this can return if range_check == range_warn. */
776 { {'<', '>'}, NOTEQUAL },
777 { {':', '='}, ASSIGN },
780 { {':', ':'}, COLONCOLON },
784 /* Some specific keywords */
791 static struct keyword keytab[] =
794 {"IN", IN },/* Note space after IN */
795 {"AND", LOGICAL_AND},
813 {"FLOAT", FLOAT_FUNC },
819 /* Read one token, getting characters through lexptr. */
821 /* This is where we will check to make sure that the language and the operators used are
835 prev_lexptr = lexptr;
840 /* See if it is a special token of length 2 */
841 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
842 if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
845 return tokentab2[i].token;
848 switch (c = *tokstart)
865 if (paren_depth == 0)
872 if (comma_terminates && paren_depth == 0)
878 /* Might be a floating point number. */
879 if (lexptr[1] >= '0' && lexptr[1] <= '9')
880 break; /* Falls into number code. */
887 /* These are character tokens that appear as-is in the YACC grammar */
910 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
913 c = tokstart[++namelen];
914 if (c >= '0' && c <= '9')
916 c = tokstart[++namelen];
917 if (c >= '0' && c <= '9')
918 c = tokstart[++namelen];
922 error("Unterminated string or character constant.");
923 yylval.sval.ptr = tokstart + 1;
924 yylval.sval.length = namelen - 1;
925 lexptr += namelen + 1;
927 if(namelen == 2) /* Single character */
929 yylval.ulval = tokstart[1];
936 /* Is it a number? */
937 /* Note: We have already dealt with the case of the token '.'.
938 See case '.' above. */
939 if ((c >= '0' && c <= '9'))
942 int got_dot = 0, got_e = 0;
948 if (!got_e && (*p == 'e' || *p == 'E'))
950 else if (!got_dot && *p == '.')
952 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
953 && (*p == '-' || *p == '+'))
954 /* This is the sign of the exponent, not the end of the
957 else if ((*p < '0' || *p > '9') &&
958 (*p < 'A' || *p > 'F') &&
959 (*p != 'H')) /* Modula-2 hexadecimal number */
962 toktype = parse_number (p - tokstart);
963 if (toktype == ERROR)
965 char *err_copy = (char *) alloca (p - tokstart + 1);
967 memcpy (err_copy, tokstart, p - tokstart);
968 err_copy[p - tokstart] = 0;
969 error ("Invalid number \"%s\".", err_copy);
975 if (!(c == '_' || c == '$'
976 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
977 /* We must have come across a bad character (e.g. ';'). */
978 error ("Invalid character '%c' in expression.", c);
980 /* It's a name. See how long it is. */
982 for (c = tokstart[namelen];
983 (c == '_' || c == '$' || (c >= '0' && c <= '9')
984 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
985 c = tokstart[++namelen])
988 /* The token "if" terminates the expression and is NOT
989 removed from the input stream. */
990 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
997 /* Lookup special keywords */
998 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
999 if (namelen == strlen (keytab[i].keyw)
1000 && strncmp (tokstart, keytab[i].keyw, namelen) == 0)
1001 return keytab[i].token;
1003 yylval.sval.ptr = tokstart;
1004 yylval.sval.length = namelen;
1006 if (*tokstart == '$')
1008 write_dollar_variable (yylval.sval);
1009 return INTERNAL_VAR;
1012 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1013 functions. If this is not so, then ...
1014 Use token-type TYPENAME for symbols that happen to be defined
1015 currently as names of types; NAME for other symbols.
1016 The caller is not constrained to care about the distinction. */
1020 char *tmp = copy_name (yylval.sval);
1023 if (lookup_partial_symtab (tmp))
1025 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0);
1026 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1028 if (lookup_typename (copy_name (yylval.sval), expression_context_block, 1))
1039 case LOC_REGPARM_ADDR:
1042 case LOC_CONST_BYTES:
1043 case LOC_OPTIMIZED_OUT:
1054 error("internal: Undefined class in m2lex()");
1057 case LOC_UNRESOLVED:
1058 error("internal: Unforseen case in m2lex()");
1061 error ("unhandled token in m2lex()");
1067 /* Built-in BOOLEAN type. This is sort of a hack. */
1068 if (strncmp (tokstart, "TRUE", 4) == 0)
1073 else if (strncmp (tokstart, "FALSE", 5) == 0)
1080 /* Must be another type of name... */
1087 make_qualname(mod,ident)
1090 char *new = malloc(strlen(mod)+strlen(ident)+2);
1104 lexptr = prev_lexptr;
1106 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);