Commit | Line | Data |
---|---|---|
14f9c5c9 | 1 | /* YACC parser for Ada expressions, for GDB. |
4c4b4cd2 PH |
2 | Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 1997, 2000, 2003, |
3 | 2004 Free Software Foundation, Inc. | |
14f9c5c9 AS |
4 | |
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program; if not, write to the Free Software | |
197e01b6 EZ |
19 | Foundation, Inc., 51 Franklin Street, Fifth Floor, |
20 | Boston, MA 02110-1301, USA. */ | |
14f9c5c9 AS |
21 | |
22 | /* Parse an Ada expression from text in a string, | |
23 | and return the result as a struct expression pointer. | |
24 | That structure contains arithmetic operations in reverse polish, | |
25 | with constants represented by operations that are followed by special data. | |
26 | See expression.h for the details of the format. | |
27 | What is important here is that it can be built up sequentially | |
28 | during the process of parsing; the lower levels of the tree always | |
29 | come first in the result. | |
30 | ||
31 | malloc's and realloc's in this file are transformed to | |
32 | xmalloc and xrealloc respectively by the same sed command in the | |
33 | makefile that remaps any other malloc/realloc inserted by the parser | |
34 | generator. Doing this with #defines and trying to control the interaction | |
35 | with include files (<malloc.h> and <stdlib.h> for example) just became | |
36 | too messy, particularly when such includes can be inserted at random | |
37 | times by the parser generator. */ | |
4c4b4cd2 | 38 | |
14f9c5c9 AS |
39 | %{ |
40 | ||
41 | #include "defs.h" | |
19c1ef65 | 42 | #include "gdb_string.h" |
14f9c5c9 AS |
43 | #include <ctype.h> |
44 | #include "expression.h" | |
45 | #include "value.h" | |
46 | #include "parser-defs.h" | |
47 | #include "language.h" | |
48 | #include "ada-lang.h" | |
49 | #include "bfd.h" /* Required by objfiles.h. */ | |
50 | #include "symfile.h" /* Required by objfiles.h. */ | |
51 | #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ | |
52 | #include "frame.h" | |
fe898f56 | 53 | #include "block.h" |
14f9c5c9 AS |
54 | |
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. 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 | |
4c4b4cd2 | 60 | generators need to be fixed instead of adding those names to this list. */ |
14f9c5c9 | 61 | |
4c4b4cd2 | 62 | /* NOTE: This is clumsy, especially since BISON and FLEX provide --prefix |
14f9c5c9 AS |
63 | options. I presume we are maintaining it to accommodate systems |
64 | without BISON? (PNH) */ | |
65 | ||
66 | #define yymaxdepth ada_maxdepth | |
67 | #define yyparse _ada_parse /* ada_parse calls this after initialization */ | |
68 | #define yylex ada_lex | |
69 | #define yyerror ada_error | |
70 | #define yylval ada_lval | |
71 | #define yychar ada_char | |
72 | #define yydebug ada_debug | |
4c4b4cd2 PH |
73 | #define yypact ada_pact |
74 | #define yyr1 ada_r1 | |
75 | #define yyr2 ada_r2 | |
76 | #define yydef ada_def | |
77 | #define yychk ada_chk | |
78 | #define yypgo ada_pgo | |
79 | #define yyact ada_act | |
14f9c5c9 AS |
80 | #define yyexca ada_exca |
81 | #define yyerrflag ada_errflag | |
82 | #define yynerrs ada_nerrs | |
83 | #define yyps ada_ps | |
84 | #define yypv ada_pv | |
85 | #define yys ada_s | |
86 | #define yy_yys ada_yys | |
87 | #define yystate ada_state | |
88 | #define yytmp ada_tmp | |
89 | #define yyv ada_v | |
90 | #define yy_yyv ada_yyv | |
91 | #define yyval ada_val | |
92 | #define yylloc ada_lloc | |
93 | #define yyreds ada_reds /* With YYDEBUG defined */ | |
94 | #define yytoks ada_toks /* With YYDEBUG defined */ | |
06891d83 JT |
95 | #define yyname ada_name /* With YYDEBUG defined */ |
96 | #define yyrule ada_rule /* With YYDEBUG defined */ | |
14f9c5c9 AS |
97 | |
98 | #ifndef YYDEBUG | |
f461f5cf | 99 | #define YYDEBUG 1 /* Default to yydebug support */ |
14f9c5c9 AS |
100 | #endif |
101 | ||
f461f5cf PM |
102 | #define YYFPRINTF parser_fprintf |
103 | ||
14f9c5c9 | 104 | struct name_info { |
4c4b4cd2 PH |
105 | struct symbol *sym; |
106 | struct minimal_symbol *msym; | |
107 | struct block *block; | |
14f9c5c9 AS |
108 | struct stoken stoken; |
109 | }; | |
110 | ||
111 | /* If expression is in the context of TYPE'(...), then TYPE, else | |
4c4b4cd2 PH |
112 | * NULL. */ |
113 | static struct type *type_qualifier; | |
14f9c5c9 AS |
114 | |
115 | int yyparse (void); | |
116 | ||
117 | static int yylex (void); | |
118 | ||
119 | void yyerror (char *); | |
120 | ||
121 | static struct stoken string_to_operator (struct stoken); | |
122 | ||
4c4b4cd2 | 123 | static void write_int (LONGEST, struct type *); |
14f9c5c9 | 124 | |
4c4b4cd2 | 125 | static void write_object_renaming (struct block *, struct symbol *, int); |
14f9c5c9 | 126 | |
4c4b4cd2 | 127 | static void write_var_from_name (struct block *, struct name_info); |
14f9c5c9 | 128 | |
19c1ef65 | 129 | static LONGEST convert_char_literal (struct type *, LONGEST); |
72d5681a PH |
130 | |
131 | static struct type *type_int (void); | |
132 | ||
133 | static struct type *type_long (void); | |
134 | ||
135 | static struct type *type_long_long (void); | |
136 | ||
137 | static struct type *type_float (void); | |
138 | ||
139 | static struct type *type_double (void); | |
140 | ||
141 | static struct type *type_long_double (void); | |
142 | ||
143 | static struct type *type_char (void); | |
144 | ||
145 | static struct type *type_system_address (void); | |
4c4b4cd2 | 146 | %} |
14f9c5c9 AS |
147 | |
148 | %union | |
149 | { | |
150 | LONGEST lval; | |
151 | struct { | |
152 | LONGEST val; | |
153 | struct type *type; | |
154 | } typed_val; | |
155 | struct { | |
156 | DOUBLEST dval; | |
157 | struct type *type; | |
158 | } typed_val_float; | |
159 | struct type *tval; | |
160 | struct stoken sval; | |
161 | struct name_info ssym; | |
162 | int voidval; | |
163 | struct block *bval; | |
164 | struct internalvar *ivar; | |
165 | ||
166 | } | |
167 | ||
168 | %type <voidval> exp exp1 simple_exp start variable | |
169 | %type <tval> type | |
170 | ||
171 | %token <typed_val> INT NULL_PTR CHARLIT | |
172 | %token <typed_val_float> FLOAT | |
173 | %token <tval> TYPENAME | |
174 | %token <bval> BLOCKNAME | |
175 | ||
176 | /* Both NAME and TYPENAME tokens represent symbols in the input, | |
177 | and both convey their data as strings. | |
178 | But a TYPENAME is a string that happens to be defined as a typedef | |
179 | or builtin type name (such as int or char) | |
180 | and a NAME is any other symbol. | |
181 | Contexts where this distinction is not important can use the | |
182 | nonterminal "name", which matches either NAME or TYPENAME. */ | |
183 | ||
4c4b4cd2 | 184 | %token <sval> STRING |
14f9c5c9 | 185 | %token <ssym> NAME DOT_ID OBJECT_RENAMING |
4c4b4cd2 | 186 | %type <bval> block |
14f9c5c9 AS |
187 | %type <lval> arglist tick_arglist |
188 | ||
189 | %type <tval> save_qualifier | |
190 | ||
191 | %token DOT_ALL | |
192 | ||
193 | /* Special type cases, put in to allow the parser to distinguish different | |
194 | legal basetypes. */ | |
4c4b4cd2 | 195 | %token <sval> SPECIAL_VARIABLE |
14f9c5c9 AS |
196 | |
197 | %nonassoc ASSIGN | |
198 | %left _AND_ OR XOR THEN ELSE | |
199 | %left '=' NOTEQUAL '<' '>' LEQ GEQ IN DOTDOT | |
200 | %left '@' | |
201 | %left '+' '-' '&' | |
202 | %left UNARY | |
203 | %left '*' '/' MOD REM | |
204 | %right STARSTAR ABS NOT | |
4c4b4cd2 PH |
205 | /* The following are right-associative only so that reductions at this |
206 | precedence have lower precedence than '.' and '('. The syntax still | |
207 | forces a.b.c, e.g., to be LEFT-associated. */ | |
14f9c5c9 AS |
208 | %right TICK_ACCESS TICK_ADDRESS TICK_FIRST TICK_LAST TICK_LENGTH |
209 | %right TICK_MAX TICK_MIN TICK_MODULUS | |
210 | %right TICK_POS TICK_RANGE TICK_SIZE TICK_TAG TICK_VAL | |
211 | %right '.' '(' '[' DOT_ID DOT_ALL | |
212 | ||
213 | %token ARROW NEW | |
214 | ||
215 | \f | |
216 | %% | |
217 | ||
218 | start : exp1 | |
219 | | type { write_exp_elt_opcode (OP_TYPE); | |
220 | write_exp_elt_type ($1); | |
221 | write_exp_elt_opcode (OP_TYPE); } | |
222 | ; | |
223 | ||
224 | /* Expressions, including the sequencing operator. */ | |
225 | exp1 : exp | |
226 | | exp1 ';' exp | |
227 | { write_exp_elt_opcode (BINOP_COMMA); } | |
228 | ; | |
229 | ||
230 | /* Expressions, not including the sequencing operator. */ | |
231 | simple_exp : simple_exp DOT_ALL | |
232 | { write_exp_elt_opcode (UNOP_IND); } | |
233 | ; | |
234 | ||
235 | simple_exp : simple_exp DOT_ID | |
236 | { write_exp_elt_opcode (STRUCTOP_STRUCT); | |
237 | write_exp_string ($2.stoken); | |
4c4b4cd2 | 238 | write_exp_elt_opcode (STRUCTOP_STRUCT); |
14f9c5c9 AS |
239 | } |
240 | ; | |
241 | ||
242 | simple_exp : simple_exp '(' arglist ')' | |
243 | { | |
244 | write_exp_elt_opcode (OP_FUNCALL); | |
245 | write_exp_elt_longcst ($3); | |
246 | write_exp_elt_opcode (OP_FUNCALL); | |
247 | } | |
248 | ; | |
249 | ||
250 | simple_exp : type '(' exp ')' | |
251 | { | |
252 | write_exp_elt_opcode (UNOP_CAST); | |
253 | write_exp_elt_type ($1); | |
4c4b4cd2 | 254 | write_exp_elt_opcode (UNOP_CAST); |
14f9c5c9 AS |
255 | } |
256 | ; | |
257 | ||
258 | simple_exp : type '\'' save_qualifier { type_qualifier = $1; } '(' exp ')' | |
259 | { | |
4c4b4cd2 | 260 | write_exp_elt_opcode (UNOP_QUAL); |
14f9c5c9 | 261 | write_exp_elt_type ($1); |
4c4b4cd2 | 262 | write_exp_elt_opcode (UNOP_QUAL); |
14f9c5c9 AS |
263 | type_qualifier = $3; |
264 | } | |
265 | ; | |
266 | ||
267 | save_qualifier : { $$ = type_qualifier; } | |
525d6a61 | 268 | ; |
14f9c5c9 AS |
269 | |
270 | simple_exp : | |
271 | simple_exp '(' exp DOTDOT exp ')' | |
272 | { write_exp_elt_opcode (TERNOP_SLICE); } | |
273 | ; | |
274 | ||
275 | simple_exp : '(' exp1 ')' { } | |
276 | ; | |
277 | ||
4c4b4cd2 | 278 | simple_exp : variable |
14f9c5c9 AS |
279 | ; |
280 | ||
4c4b4cd2 PH |
281 | simple_exp: SPECIAL_VARIABLE /* Various GDB extensions */ |
282 | { write_dollar_variable ($1); } | |
14f9c5c9 AS |
283 | ; |
284 | ||
14f9c5c9 AS |
285 | exp : simple_exp |
286 | ; | |
287 | ||
14f9c5c9 AS |
288 | exp : exp ASSIGN exp /* Extension for convenience */ |
289 | { write_exp_elt_opcode (BINOP_ASSIGN); } | |
290 | ; | |
291 | ||
292 | exp : '-' exp %prec UNARY | |
293 | { write_exp_elt_opcode (UNOP_NEG); } | |
294 | ; | |
295 | ||
296 | exp : '+' exp %prec UNARY | |
297 | { write_exp_elt_opcode (UNOP_PLUS); } | |
298 | ; | |
299 | ||
300 | exp : NOT exp %prec UNARY | |
301 | { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } | |
302 | ; | |
303 | ||
304 | exp : ABS exp %prec UNARY | |
305 | { write_exp_elt_opcode (UNOP_ABS); } | |
306 | ; | |
307 | ||
308 | arglist : { $$ = 0; } | |
309 | ; | |
310 | ||
311 | arglist : exp | |
312 | { $$ = 1; } | |
313 | | any_name ARROW exp | |
314 | { $$ = 1; } | |
315 | | arglist ',' exp | |
316 | { $$ = $1 + 1; } | |
317 | | arglist ',' any_name ARROW exp | |
318 | { $$ = $1 + 1; } | |
319 | ; | |
320 | ||
321 | exp : '{' type '}' exp %prec '.' | |
322 | /* GDB extension */ | |
323 | { write_exp_elt_opcode (UNOP_MEMVAL); | |
324 | write_exp_elt_type ($2); | |
4c4b4cd2 | 325 | write_exp_elt_opcode (UNOP_MEMVAL); |
14f9c5c9 AS |
326 | } |
327 | ; | |
328 | ||
329 | /* Binary operators in order of decreasing precedence. */ | |
330 | ||
331 | exp : exp STARSTAR exp | |
332 | { write_exp_elt_opcode (BINOP_EXP); } | |
333 | ; | |
334 | ||
335 | exp : exp '*' exp | |
336 | { write_exp_elt_opcode (BINOP_MUL); } | |
337 | ; | |
338 | ||
339 | exp : exp '/' exp | |
340 | { write_exp_elt_opcode (BINOP_DIV); } | |
341 | ; | |
342 | ||
343 | exp : exp REM exp /* May need to be fixed to give correct Ada REM */ | |
344 | { write_exp_elt_opcode (BINOP_REM); } | |
345 | ; | |
346 | ||
347 | exp : exp MOD exp | |
348 | { write_exp_elt_opcode (BINOP_MOD); } | |
349 | ; | |
350 | ||
351 | exp : exp '@' exp /* GDB extension */ | |
352 | { write_exp_elt_opcode (BINOP_REPEAT); } | |
353 | ; | |
354 | ||
355 | exp : exp '+' exp | |
356 | { write_exp_elt_opcode (BINOP_ADD); } | |
357 | ; | |
358 | ||
359 | exp : exp '&' exp | |
360 | { write_exp_elt_opcode (BINOP_CONCAT); } | |
361 | ; | |
362 | ||
363 | exp : exp '-' exp | |
364 | { write_exp_elt_opcode (BINOP_SUB); } | |
365 | ; | |
366 | ||
367 | exp : exp '=' exp | |
368 | { write_exp_elt_opcode (BINOP_EQUAL); } | |
369 | ; | |
370 | ||
371 | exp : exp NOTEQUAL exp | |
372 | { write_exp_elt_opcode (BINOP_NOTEQUAL); } | |
373 | ; | |
374 | ||
375 | exp : exp LEQ exp | |
376 | { write_exp_elt_opcode (BINOP_LEQ); } | |
377 | ; | |
378 | ||
379 | exp : exp IN exp DOTDOT exp | |
4c4b4cd2 | 380 | { write_exp_elt_opcode (TERNOP_IN_RANGE); } |
14f9c5c9 | 381 | | exp IN exp TICK_RANGE tick_arglist |
4c4b4cd2 | 382 | { write_exp_elt_opcode (BINOP_IN_BOUNDS); |
14f9c5c9 | 383 | write_exp_elt_longcst ((LONGEST) $5); |
4c4b4cd2 | 384 | write_exp_elt_opcode (BINOP_IN_BOUNDS); |
14f9c5c9 AS |
385 | } |
386 | | exp IN TYPENAME %prec TICK_ACCESS | |
4c4b4cd2 | 387 | { write_exp_elt_opcode (UNOP_IN_RANGE); |
14f9c5c9 | 388 | write_exp_elt_type ($3); |
4c4b4cd2 | 389 | write_exp_elt_opcode (UNOP_IN_RANGE); |
14f9c5c9 AS |
390 | } |
391 | | exp NOT IN exp DOTDOT exp | |
4c4b4cd2 PH |
392 | { write_exp_elt_opcode (TERNOP_IN_RANGE); |
393 | write_exp_elt_opcode (UNOP_LOGICAL_NOT); | |
14f9c5c9 AS |
394 | } |
395 | | exp NOT IN exp TICK_RANGE tick_arglist | |
4c4b4cd2 | 396 | { write_exp_elt_opcode (BINOP_IN_BOUNDS); |
14f9c5c9 | 397 | write_exp_elt_longcst ((LONGEST) $6); |
4c4b4cd2 PH |
398 | write_exp_elt_opcode (BINOP_IN_BOUNDS); |
399 | write_exp_elt_opcode (UNOP_LOGICAL_NOT); | |
14f9c5c9 AS |
400 | } |
401 | | exp NOT IN TYPENAME %prec TICK_ACCESS | |
4c4b4cd2 | 402 | { write_exp_elt_opcode (UNOP_IN_RANGE); |
14f9c5c9 | 403 | write_exp_elt_type ($4); |
4c4b4cd2 PH |
404 | write_exp_elt_opcode (UNOP_IN_RANGE); |
405 | write_exp_elt_opcode (UNOP_LOGICAL_NOT); | |
14f9c5c9 AS |
406 | } |
407 | ; | |
408 | ||
409 | exp : exp GEQ exp | |
410 | { write_exp_elt_opcode (BINOP_GEQ); } | |
411 | ; | |
412 | ||
413 | exp : exp '<' exp | |
414 | { write_exp_elt_opcode (BINOP_LESS); } | |
415 | ; | |
416 | ||
417 | exp : exp '>' exp | |
418 | { write_exp_elt_opcode (BINOP_GTR); } | |
419 | ; | |
420 | ||
4c4b4cd2 | 421 | exp : exp _AND_ exp /* Fix for Ada elementwise AND. */ |
14f9c5c9 AS |
422 | { write_exp_elt_opcode (BINOP_BITWISE_AND); } |
423 | ; | |
424 | ||
425 | exp : exp _AND_ THEN exp %prec _AND_ | |
426 | { write_exp_elt_opcode (BINOP_LOGICAL_AND); } | |
427 | ; | |
428 | ||
429 | exp : exp OR exp /* Fix for Ada elementwise OR */ | |
430 | { write_exp_elt_opcode (BINOP_BITWISE_IOR); } | |
431 | ; | |
432 | ||
4c4b4cd2 | 433 | exp : exp OR ELSE exp |
14f9c5c9 AS |
434 | { write_exp_elt_opcode (BINOP_LOGICAL_OR); } |
435 | ; | |
436 | ||
437 | exp : exp XOR exp /* Fix for Ada elementwise XOR */ | |
438 | { write_exp_elt_opcode (BINOP_BITWISE_XOR); } | |
439 | ; | |
440 | ||
441 | simple_exp : simple_exp TICK_ACCESS | |
442 | { write_exp_elt_opcode (UNOP_ADDR); } | |
443 | | simple_exp TICK_ADDRESS | |
444 | { write_exp_elt_opcode (UNOP_ADDR); | |
445 | write_exp_elt_opcode (UNOP_CAST); | |
72d5681a | 446 | write_exp_elt_type (type_system_address ()); |
14f9c5c9 AS |
447 | write_exp_elt_opcode (UNOP_CAST); |
448 | } | |
449 | | simple_exp TICK_FIRST tick_arglist | |
72d5681a | 450 | { write_int ($3, type_int ()); |
4c4b4cd2 | 451 | write_exp_elt_opcode (OP_ATR_FIRST); } |
14f9c5c9 | 452 | | simple_exp TICK_LAST tick_arglist |
72d5681a | 453 | { write_int ($3, type_int ()); |
4c4b4cd2 | 454 | write_exp_elt_opcode (OP_ATR_LAST); } |
14f9c5c9 | 455 | | simple_exp TICK_LENGTH tick_arglist |
72d5681a | 456 | { write_int ($3, type_int ()); |
4c4b4cd2 PH |
457 | write_exp_elt_opcode (OP_ATR_LENGTH); } |
458 | | simple_exp TICK_SIZE | |
459 | { write_exp_elt_opcode (OP_ATR_SIZE); } | |
14f9c5c9 | 460 | | simple_exp TICK_TAG |
4c4b4cd2 | 461 | { write_exp_elt_opcode (OP_ATR_TAG); } |
14f9c5c9 | 462 | | opt_type_prefix TICK_MIN '(' exp ',' exp ')' |
4c4b4cd2 | 463 | { write_exp_elt_opcode (OP_ATR_MIN); } |
14f9c5c9 | 464 | | opt_type_prefix TICK_MAX '(' exp ',' exp ')' |
4c4b4cd2 | 465 | { write_exp_elt_opcode (OP_ATR_MAX); } |
14f9c5c9 | 466 | | opt_type_prefix TICK_POS '(' exp ')' |
4c4b4cd2 | 467 | { write_exp_elt_opcode (OP_ATR_POS); } |
14f9c5c9 | 468 | | type_prefix TICK_FIRST tick_arglist |
72d5681a | 469 | { write_int ($3, type_int ()); |
4c4b4cd2 | 470 | write_exp_elt_opcode (OP_ATR_FIRST); } |
14f9c5c9 | 471 | | type_prefix TICK_LAST tick_arglist |
72d5681a | 472 | { write_int ($3, type_int ()); |
4c4b4cd2 | 473 | write_exp_elt_opcode (OP_ATR_LAST); } |
14f9c5c9 | 474 | | type_prefix TICK_LENGTH tick_arglist |
72d5681a | 475 | { write_int ($3, type_int ()); |
4c4b4cd2 | 476 | write_exp_elt_opcode (OP_ATR_LENGTH); } |
14f9c5c9 | 477 | | type_prefix TICK_VAL '(' exp ')' |
4c4b4cd2 PH |
478 | { write_exp_elt_opcode (OP_ATR_VAL); } |
479 | | type_prefix TICK_MODULUS | |
480 | { write_exp_elt_opcode (OP_ATR_MODULUS); } | |
14f9c5c9 AS |
481 | ; |
482 | ||
483 | tick_arglist : %prec '(' | |
484 | { $$ = 1; } | |
485 | | '(' INT ')' | |
486 | { $$ = $2.val; } | |
487 | ; | |
488 | ||
489 | type_prefix : | |
490 | TYPENAME | |
491 | { write_exp_elt_opcode (OP_TYPE); | |
492 | write_exp_elt_type ($1); | |
493 | write_exp_elt_opcode (OP_TYPE); } | |
494 | ; | |
495 | ||
496 | opt_type_prefix : | |
497 | type_prefix | |
4c4b4cd2 | 498 | | /* EMPTY */ |
14f9c5c9 AS |
499 | { write_exp_elt_opcode (OP_TYPE); |
500 | write_exp_elt_type (builtin_type_void); | |
501 | write_exp_elt_opcode (OP_TYPE); } | |
502 | ; | |
4c4b4cd2 | 503 | |
14f9c5c9 AS |
504 | |
505 | exp : INT | |
4c4b4cd2 | 506 | { write_int ((LONGEST) $1.val, $1.type); } |
14f9c5c9 AS |
507 | ; |
508 | ||
509 | exp : CHARLIT | |
4c4b4cd2 PH |
510 | { write_int (convert_char_literal (type_qualifier, $1.val), |
511 | (type_qualifier == NULL) | |
512 | ? $1.type : type_qualifier); | |
513 | } | |
525d6a61 | 514 | ; |
4c4b4cd2 | 515 | |
14f9c5c9 AS |
516 | exp : FLOAT |
517 | { write_exp_elt_opcode (OP_DOUBLE); | |
518 | write_exp_elt_type ($1.type); | |
519 | write_exp_elt_dblcst ($1.dval); | |
4c4b4cd2 | 520 | write_exp_elt_opcode (OP_DOUBLE); |
14f9c5c9 AS |
521 | } |
522 | ; | |
523 | ||
524 | exp : NULL_PTR | |
72d5681a | 525 | { write_int (0, type_int ()); } |
525d6a61 | 526 | ; |
14f9c5c9 AS |
527 | |
528 | exp : STRING | |
4c4b4cd2 PH |
529 | { |
530 | write_exp_elt_opcode (OP_STRING); | |
531 | write_exp_string ($1); | |
532 | write_exp_elt_opcode (OP_STRING); | |
533 | } | |
14f9c5c9 AS |
534 | ; |
535 | ||
536 | exp : NEW TYPENAME | |
537 | { error ("NEW not implemented."); } | |
538 | ; | |
539 | ||
540 | variable: NAME { write_var_from_name (NULL, $1); } | |
541 | | block NAME /* GDB extension */ | |
542 | { write_var_from_name ($1, $2); } | |
4c4b4cd2 PH |
543 | | OBJECT_RENAMING |
544 | { write_object_renaming (NULL, $1.sym, | |
545 | MAX_RENAMING_CHAIN_LENGTH); } | |
546 | | block OBJECT_RENAMING | |
547 | { write_object_renaming ($1, $2.sym, | |
548 | MAX_RENAMING_CHAIN_LENGTH); } | |
14f9c5c9 AS |
549 | ; |
550 | ||
551 | any_name : NAME { } | |
552 | | TYPENAME { } | |
553 | | OBJECT_RENAMING { } | |
554 | ; | |
555 | ||
556 | block : BLOCKNAME /* GDB extension */ | |
557 | { $$ = $1; } | |
558 | | block BLOCKNAME /* GDB extension */ | |
559 | { $$ = $2; } | |
560 | ; | |
561 | ||
562 | ||
563 | type : TYPENAME { $$ = $1; } | |
564 | | block TYPENAME { $$ = $2; } | |
4c4b4cd2 | 565 | | TYPENAME TICK_ACCESS |
14f9c5c9 AS |
566 | { $$ = lookup_pointer_type ($1); } |
567 | | block TYPENAME TICK_ACCESS | |
568 | { $$ = lookup_pointer_type ($2); } | |
569 | ; | |
570 | ||
571 | /* Some extensions borrowed from C, for the benefit of those who find they | |
4c4b4cd2 | 572 | can't get used to Ada notation in GDB. */ |
14f9c5c9 AS |
573 | |
574 | exp : '*' exp %prec '.' | |
575 | { write_exp_elt_opcode (UNOP_IND); } | |
576 | | '&' exp %prec '.' | |
577 | { write_exp_elt_opcode (UNOP_ADDR); } | |
578 | | exp '[' exp ']' | |
579 | { write_exp_elt_opcode (BINOP_SUBSCRIPT); } | |
580 | ; | |
581 | ||
582 | %% | |
583 | ||
584 | /* yylex defined in ada-lex.c: Reads one token, getting characters */ | |
585 | /* through lexptr. */ | |
586 | ||
587 | /* Remap normal flex interface names (yylex) as well as gratuitiously */ | |
588 | /* global symbol names, so we can have multiple flex-generated parsers */ | |
589 | /* in gdb. */ | |
590 | ||
591 | /* (See note above on previous definitions for YACC.) */ | |
592 | ||
593 | #define yy_create_buffer ada_yy_create_buffer | |
594 | #define yy_delete_buffer ada_yy_delete_buffer | |
595 | #define yy_init_buffer ada_yy_init_buffer | |
596 | #define yy_load_buffer_state ada_yy_load_buffer_state | |
597 | #define yy_switch_to_buffer ada_yy_switch_to_buffer | |
598 | #define yyrestart ada_yyrestart | |
599 | #define yytext ada_yytext | |
600 | #define yywrap ada_yywrap | |
601 | ||
4c4b4cd2 PH |
602 | static struct obstack temp_parse_space; |
603 | ||
14f9c5c9 AS |
604 | /* The following kludge was found necessary to prevent conflicts between */ |
605 | /* defs.h and non-standard stdlib.h files. */ | |
606 | #define qsort __qsort__dummy | |
607 | #include "ada-lex.c" | |
608 | ||
609 | int | |
4c4b4cd2 | 610 | ada_parse (void) |
14f9c5c9 | 611 | { |
4c4b4cd2 | 612 | lexer_init (yyin); /* (Re-)initialize lexer. */ |
14f9c5c9 AS |
613 | left_block_context = NULL; |
614 | type_qualifier = NULL; | |
4c4b4cd2 PH |
615 | obstack_free (&temp_parse_space, NULL); |
616 | obstack_init (&temp_parse_space); | |
617 | ||
14f9c5c9 AS |
618 | return _ada_parse (); |
619 | } | |
620 | ||
621 | void | |
4c4b4cd2 | 622 | yyerror (char *msg) |
14f9c5c9 AS |
623 | { |
624 | error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); | |
625 | } | |
626 | ||
4c4b4cd2 | 627 | /* The operator name corresponding to operator symbol STRING (adds |
14f9c5c9 AS |
628 | quotes and maps to lower-case). Destroys the previous contents of |
629 | the array pointed to by STRING.ptr. Error if STRING does not match | |
630 | a valid Ada operator. Assumes that STRING.ptr points to a | |
631 | null-terminated string and that, if STRING is a valid operator | |
632 | symbol, the array pointed to by STRING.ptr contains at least | |
4c4b4cd2 | 633 | STRING.length+3 characters. */ |
14f9c5c9 AS |
634 | |
635 | static struct stoken | |
4c4b4cd2 | 636 | string_to_operator (struct stoken string) |
14f9c5c9 AS |
637 | { |
638 | int i; | |
639 | ||
4c4b4cd2 | 640 | for (i = 0; ada_opname_table[i].encoded != NULL; i += 1) |
14f9c5c9 | 641 | { |
4c4b4cd2 PH |
642 | if (string.length == strlen (ada_opname_table[i].decoded)-2 |
643 | && strncasecmp (string.ptr, ada_opname_table[i].decoded+1, | |
14f9c5c9 AS |
644 | string.length) == 0) |
645 | { | |
4c4b4cd2 | 646 | strncpy (string.ptr, ada_opname_table[i].decoded, |
14f9c5c9 AS |
647 | string.length+2); |
648 | string.length += 2; | |
649 | return string; | |
650 | } | |
651 | } | |
652 | error ("Invalid operator symbol `%s'", string.ptr); | |
653 | } | |
654 | ||
655 | /* Emit expression to access an instance of SYM, in block BLOCK (if | |
4c4b4cd2 | 656 | * non-NULL), and with :: qualification ORIG_LEFT_CONTEXT. */ |
14f9c5c9 | 657 | static void |
4c4b4cd2 PH |
658 | write_var_from_sym (struct block *orig_left_context, |
659 | struct block *block, | |
660 | struct symbol *sym) | |
14f9c5c9 AS |
661 | { |
662 | if (orig_left_context == NULL && symbol_read_needs_frame (sym)) | |
663 | { | |
c3e5cd34 PH |
664 | if (innermost_block == 0 |
665 | || contained_in (block, innermost_block)) | |
14f9c5c9 AS |
666 | innermost_block = block; |
667 | } | |
668 | ||
669 | write_exp_elt_opcode (OP_VAR_VALUE); | |
4c4b4cd2 | 670 | write_exp_elt_block (block); |
14f9c5c9 AS |
671 | write_exp_elt_sym (sym); |
672 | write_exp_elt_opcode (OP_VAR_VALUE); | |
673 | } | |
674 | ||
4c4b4cd2 PH |
675 | /* Emit expression to access an instance of NAME in :: context |
676 | * ORIG_LEFT_CONTEXT. If no unique symbol for NAME has been found, | |
677 | * output a dummy symbol (good to the next call of ada_parse) for NAME | |
678 | * in the UNDEF_DOMAIN, for later resolution by ada_resolve. */ | |
14f9c5c9 | 679 | static void |
4c4b4cd2 PH |
680 | write_var_from_name (struct block *orig_left_context, |
681 | struct name_info name) | |
14f9c5c9 AS |
682 | { |
683 | if (name.msym != NULL) | |
684 | { | |
4c4b4cd2 | 685 | write_exp_msymbol (name.msym, |
72d5681a PH |
686 | lookup_function_type (type_int ()), |
687 | type_int ()); | |
14f9c5c9 | 688 | } |
4c4b4cd2 | 689 | else if (name.sym == NULL) |
14f9c5c9 | 690 | { |
4c4b4cd2 PH |
691 | /* Multiple matches: record name and starting block for later |
692 | resolution by ada_resolve. */ | |
693 | char *encoded_name = ada_encode (name.stoken.ptr); | |
694 | struct symbol *sym = | |
695 | obstack_alloc (&temp_parse_space, sizeof (struct symbol)); | |
696 | memset (sym, 0, sizeof (struct symbol)); | |
697 | SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN; | |
698 | SYMBOL_LINKAGE_NAME (sym) | |
699 | = obsavestring (encoded_name, strlen (encoded_name), &temp_parse_space); | |
700 | SYMBOL_LANGUAGE (sym) = language_ada; | |
701 | ||
702 | write_exp_elt_opcode (OP_VAR_VALUE); | |
14f9c5c9 | 703 | write_exp_elt_block (name.block); |
4c4b4cd2 PH |
704 | write_exp_elt_sym (sym); |
705 | write_exp_elt_opcode (OP_VAR_VALUE); | |
14f9c5c9 AS |
706 | } |
707 | else | |
708 | write_var_from_sym (orig_left_context, name.block, name.sym); | |
709 | } | |
710 | ||
4c4b4cd2 | 711 | /* Write integer constant ARG of type TYPE. */ |
14f9c5c9 AS |
712 | |
713 | static void | |
4c4b4cd2 | 714 | write_int (LONGEST arg, struct type *type) |
14f9c5c9 AS |
715 | { |
716 | write_exp_elt_opcode (OP_LONG); | |
4c4b4cd2 | 717 | write_exp_elt_type (type); |
14f9c5c9 AS |
718 | write_exp_elt_longcst (arg); |
719 | write_exp_elt_opcode (OP_LONG); | |
4c4b4cd2 | 720 | } |
14f9c5c9 | 721 | |
4c4b4cd2 | 722 | /* Emit expression corresponding to the renamed object designated by |
14f9c5c9 | 723 | * the type RENAMING, which must be the referent of an object renaming |
4c4b4cd2 PH |
724 | * type, in the context of ORIG_LEFT_CONTEXT. MAX_DEPTH is the maximum |
725 | * number of cascaded renamings to allow. */ | |
14f9c5c9 | 726 | static void |
4c4b4cd2 PH |
727 | write_object_renaming (struct block *orig_left_context, |
728 | struct symbol *renaming, int max_depth) | |
14f9c5c9 | 729 | { |
4c4b4cd2 PH |
730 | const char *qualification = SYMBOL_LINKAGE_NAME (renaming); |
731 | const char *simple_tail; | |
732 | const char *expr = TYPE_FIELD_NAME (SYMBOL_TYPE (renaming), 0); | |
733 | const char *suffix; | |
734 | char *name; | |
735 | struct symbol *sym; | |
14f9c5c9 AS |
736 | enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state; |
737 | ||
4c4b4cd2 PH |
738 | if (max_depth <= 0) |
739 | error ("Could not find renamed symbol"); | |
740 | ||
14f9c5c9 | 741 | /* if orig_left_context is null, then use the currently selected |
4c4b4cd2 | 742 | block; otherwise we might fail our symbol lookup below. */ |
14f9c5c9 AS |
743 | if (orig_left_context == NULL) |
744 | orig_left_context = get_selected_block (NULL); | |
745 | ||
4c4b4cd2 | 746 | for (simple_tail = qualification + strlen (qualification); |
14f9c5c9 AS |
747 | simple_tail != qualification; simple_tail -= 1) |
748 | { | |
749 | if (*simple_tail == '.') | |
750 | { | |
751 | simple_tail += 1; | |
752 | break; | |
4c4b4cd2 PH |
753 | } |
754 | else if (strncmp (simple_tail, "__", 2) == 0) | |
14f9c5c9 AS |
755 | { |
756 | simple_tail += 2; | |
757 | break; | |
758 | } | |
759 | } | |
760 | ||
761 | suffix = strstr (expr, "___XE"); | |
762 | if (suffix == NULL) | |
763 | goto BadEncoding; | |
764 | ||
4c4b4cd2 | 765 | name = (char *) obstack_alloc (&temp_parse_space, suffix - expr + 1); |
14f9c5c9 AS |
766 | strncpy (name, expr, suffix-expr); |
767 | name[suffix-expr] = '\000'; | |
176620f1 | 768 | sym = lookup_symbol (name, orig_left_context, VAR_DOMAIN, 0, NULL); |
4c4b4cd2 PH |
769 | if (sym == NULL) |
770 | error ("Could not find renamed variable: %s", ada_decode (name)); | |
771 | if (ada_is_object_renaming (sym)) | |
772 | write_object_renaming (orig_left_context, sym, max_depth-1); | |
773 | else | |
774 | write_var_from_sym (orig_left_context, block_found, sym); | |
14f9c5c9 AS |
775 | |
776 | suffix += 5; | |
777 | slice_state = SIMPLE_INDEX; | |
4c4b4cd2 | 778 | while (*suffix == 'X') |
14f9c5c9 AS |
779 | { |
780 | suffix += 1; | |
781 | ||
782 | switch (*suffix) { | |
4c4b4cd2 PH |
783 | case 'A': |
784 | suffix += 1; | |
785 | write_exp_elt_opcode (UNOP_IND); | |
786 | break; | |
14f9c5c9 AS |
787 | case 'L': |
788 | slice_state = LOWER_BOUND; | |
789 | case 'S': | |
790 | suffix += 1; | |
4c4b4cd2 | 791 | if (isdigit (*suffix)) |
14f9c5c9 | 792 | { |
4c4b4cd2 | 793 | char *next; |
14f9c5c9 | 794 | long val = strtol (suffix, &next, 10); |
4c4b4cd2 | 795 | if (next == suffix) |
14f9c5c9 AS |
796 | goto BadEncoding; |
797 | suffix = next; | |
798 | write_exp_elt_opcode (OP_LONG); | |
72d5681a | 799 | write_exp_elt_type (type_int ()); |
14f9c5c9 AS |
800 | write_exp_elt_longcst ((LONGEST) val); |
801 | write_exp_elt_opcode (OP_LONG); | |
4c4b4cd2 | 802 | } |
14f9c5c9 AS |
803 | else |
804 | { | |
4c4b4cd2 PH |
805 | const char *end; |
806 | char *index_name; | |
14f9c5c9 | 807 | int index_len; |
4c4b4cd2 | 808 | struct symbol *index_sym; |
14f9c5c9 AS |
809 | |
810 | end = strchr (suffix, 'X'); | |
4c4b4cd2 | 811 | if (end == NULL) |
14f9c5c9 | 812 | end = suffix + strlen (suffix); |
4c4b4cd2 | 813 | |
14f9c5c9 | 814 | index_len = simple_tail - qualification + 2 + (suffix - end) + 1; |
4c4b4cd2 PH |
815 | index_name |
816 | = (char *) obstack_alloc (&temp_parse_space, index_len); | |
14f9c5c9 | 817 | memset (index_name, '\000', index_len); |
14f9c5c9 AS |
818 | strncpy (index_name, qualification, simple_tail - qualification); |
819 | index_name[simple_tail - qualification] = '\000'; | |
820 | strncat (index_name, suffix, suffix-end); | |
821 | suffix = end; | |
822 | ||
4c4b4cd2 | 823 | index_sym = |
176620f1 | 824 | lookup_symbol (index_name, NULL, VAR_DOMAIN, 0, NULL); |
14f9c5c9 AS |
825 | if (index_sym == NULL) |
826 | error ("Could not find %s", index_name); | |
827 | write_var_from_sym (NULL, block_found, sym); | |
828 | } | |
829 | if (slice_state == SIMPLE_INDEX) | |
4c4b4cd2 | 830 | { |
14f9c5c9 AS |
831 | write_exp_elt_opcode (OP_FUNCALL); |
832 | write_exp_elt_longcst ((LONGEST) 1); | |
833 | write_exp_elt_opcode (OP_FUNCALL); | |
834 | } | |
835 | else if (slice_state == LOWER_BOUND) | |
836 | slice_state = UPPER_BOUND; | |
837 | else if (slice_state == UPPER_BOUND) | |
838 | { | |
839 | write_exp_elt_opcode (TERNOP_SLICE); | |
840 | slice_state = SIMPLE_INDEX; | |
841 | } | |
842 | break; | |
843 | ||
844 | case 'R': | |
845 | { | |
846 | struct stoken field_name; | |
4c4b4cd2 | 847 | const char *end; |
14f9c5c9 | 848 | suffix += 1; |
4c4b4cd2 | 849 | |
14f9c5c9 AS |
850 | if (slice_state != SIMPLE_INDEX) |
851 | goto BadEncoding; | |
852 | end = strchr (suffix, 'X'); | |
4c4b4cd2 | 853 | if (end == NULL) |
14f9c5c9 AS |
854 | end = suffix + strlen (suffix); |
855 | field_name.length = end - suffix; | |
34a17005 | 856 | field_name.ptr = xmalloc (end - suffix + 1); |
14f9c5c9 AS |
857 | strncpy (field_name.ptr, suffix, end - suffix); |
858 | field_name.ptr[end - suffix] = '\000'; | |
859 | suffix = end; | |
860 | write_exp_elt_opcode (STRUCTOP_STRUCT); | |
861 | write_exp_string (field_name); | |
4c4b4cd2 | 862 | write_exp_elt_opcode (STRUCTOP_STRUCT); |
14f9c5c9 AS |
863 | break; |
864 | } | |
4c4b4cd2 | 865 | |
14f9c5c9 AS |
866 | default: |
867 | goto BadEncoding; | |
868 | } | |
869 | } | |
870 | if (slice_state == SIMPLE_INDEX) | |
871 | return; | |
872 | ||
873 | BadEncoding: | |
874 | error ("Internal error in encoding of renaming declaration: %s", | |
4c4b4cd2 | 875 | SYMBOL_LINKAGE_NAME (renaming)); |
14f9c5c9 AS |
876 | } |
877 | ||
878 | /* Convert the character literal whose ASCII value would be VAL to the | |
879 | appropriate value of type TYPE, if there is a translation. | |
4c4b4cd2 PH |
880 | Otherwise return VAL. Hence, in an enumeration type ('A', 'B'), |
881 | the literal 'A' (VAL == 65), returns 0. */ | |
14f9c5c9 | 882 | static LONGEST |
4c4b4cd2 | 883 | convert_char_literal (struct type *type, LONGEST val) |
14f9c5c9 AS |
884 | { |
885 | char name[7]; | |
886 | int f; | |
887 | ||
888 | if (type == NULL || TYPE_CODE (type) != TYPE_CODE_ENUM) | |
889 | return val; | |
890 | sprintf (name, "QU%02x", (int) val); | |
4c4b4cd2 | 891 | for (f = 0; f < TYPE_NFIELDS (type); f += 1) |
14f9c5c9 | 892 | { |
4c4b4cd2 | 893 | if (strcmp (name, TYPE_FIELD_NAME (type, f)) == 0) |
14f9c5c9 AS |
894 | return TYPE_FIELD_BITPOS (type, f); |
895 | } | |
896 | return val; | |
897 | } | |
4c4b4cd2 | 898 | |
72d5681a PH |
899 | static struct type * |
900 | type_int (void) | |
901 | { | |
902 | return builtin_type (current_gdbarch)->builtin_int; | |
903 | } | |
904 | ||
905 | static struct type * | |
906 | type_long (void) | |
907 | { | |
908 | return builtin_type (current_gdbarch)->builtin_long; | |
909 | } | |
910 | ||
911 | static struct type * | |
912 | type_long_long (void) | |
913 | { | |
914 | return builtin_type (current_gdbarch)->builtin_long_long; | |
915 | } | |
916 | ||
917 | static struct type * | |
918 | type_float (void) | |
919 | { | |
920 | return builtin_type (current_gdbarch)->builtin_float; | |
921 | } | |
922 | ||
923 | static struct type * | |
924 | type_double (void) | |
925 | { | |
926 | return builtin_type (current_gdbarch)->builtin_double; | |
927 | } | |
928 | ||
929 | static struct type * | |
930 | type_long_double (void) | |
931 | { | |
932 | return builtin_type (current_gdbarch)->builtin_long_double; | |
933 | } | |
934 | ||
935 | static struct type * | |
936 | type_char (void) | |
937 | { | |
938 | return language_string_char_type (current_language, current_gdbarch); | |
939 | } | |
940 | ||
941 | static struct type * | |
942 | type_system_address (void) | |
943 | { | |
944 | struct type *type | |
945 | = language_lookup_primitive_type_by_name (current_language, | |
946 | current_gdbarch, | |
947 | "system__address"); | |
948 | return type != NULL ? type : lookup_pointer_type (builtin_type_void); | |
949 | } | |
950 | ||
4c4b4cd2 PH |
951 | void |
952 | _initialize_ada_exp (void) | |
953 | { | |
954 | obstack_init (&temp_parse_space); | |
955 | } | |
23485554 PH |
956 | |
957 | /* FIXME: hilfingr/2004-10-05: Hack to remove warning. The function | |
958 | string_to_operator is supposed to be used for cases where one | |
959 | calls an operator function with prefix notation, as in | |
960 | "+" (a, b), but at some point, this code seems to have gone | |
961 | missing. */ | |
962 | ||
963 | struct stoken (*dummy_string_to_ada_operator) (struct stoken) | |
964 | = string_to_operator; | |
965 |