]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/c-exp.y
projects / thirdparty / binutils-gdb.git / blob
? search:


7ebefcbd9df0920d1f3ee18261a83e0f2eea78f3
[thirdparty/binutils-gdb.git] / gdb / c-exp.y
1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2003, 2004, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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 2 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
22
23 /* Parse a C expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result.
31
32 Note that malloc's and realloc's in this file are transformed to
33 xmalloc and xrealloc respectively by the same sed command in the
34 makefile that remaps any other malloc/realloc inserted by the parser
35 generator. Doing this with #defines and trying to control the interaction
36 with include files (<malloc.h> and <stdlib.h> for example) just became
37 too messy, particularly when such includes can be inserted at random
38 times by the parser generator. */
39
40 %{
41
42 #include "defs.h"
43 #include "gdb_string.h"
44 #include <ctype.h>
45 #include "expression.h"
46 #include "value.h"
47 #include "parser-defs.h"
48 #include "language.h"
49 #include "c-lang.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 */
53 #include "charset.h"
54 #include "block.h"
55 #include "cp-support.h"
56 #include "dfp.h"
57
58 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
59 as well as gratuitiously global symbol names, so we can have multiple
60 yacc generated parsers in gdb. Note that these are only the variables
61 produced by yacc. If other parser generators (bison, byacc, etc) produce
62 additional global names that conflict at link time, then those parser
63 generators need to be fixed instead of adding those names to this list. */
64
65 #define yymaxdepth c_maxdepth
66 #define yyparse c_parse_internal
67 #define yylex c_lex
68 #define yyerror c_error
69 #define yylval c_lval
70 #define yychar c_char
71 #define yydebug c_debug
72 #define yypact c_pact
73 #define yyr1 c_r1
74 #define yyr2 c_r2
75 #define yydef c_def
76 #define yychk c_chk
77 #define yypgo c_pgo
78 #define yyact c_act
79 #define yyexca c_exca
80 #define yyerrflag c_errflag
81 #define yynerrs c_nerrs
82 #define yyps c_ps
83 #define yypv c_pv
84 #define yys c_s
85 #define yy_yys c_yys
86 #define yystate c_state
87 #define yytmp c_tmp
88 #define yyv c_v
89 #define yy_yyv c_yyv
90 #define yyval c_val
91 #define yylloc c_lloc
92 #define yyreds c_reds /* With YYDEBUG defined */
93 #define yytoks c_toks /* With YYDEBUG defined */
94 #define yyname c_name /* With YYDEBUG defined */
95 #define yyrule c_rule /* With YYDEBUG defined */
96 #define yylhs c_yylhs
97 #define yylen c_yylen
98 #define yydefred c_yydefred
99 #define yydgoto c_yydgoto
100 #define yysindex c_yysindex
101 #define yyrindex c_yyrindex
102 #define yygindex c_yygindex
103 #define yytable c_yytable
104 #define yycheck c_yycheck
105
106 #ifndef YYDEBUG
107 #define YYDEBUG 1 /* Default to yydebug support */
108 #endif
109
110 #define YYFPRINTF parser_fprintf
111
112 int yyparse (void);
113
114 static int yylex (void);
115
116 void yyerror (char *);
117
118 %}
119
120 /* Although the yacc "value" of an expression is not used,
121 since the result is stored in the structure being created,
122 other node types do have values. */
123
124 %union
125 {
126 LONGEST lval;
127 struct {
128 LONGEST val;
129 struct type *type;
130 } typed_val_int;
131 struct {
132 DOUBLEST dval;
133 struct type *type;
134 } typed_val_float;
135 struct {
136 gdb_byte val[16];
137 struct type *type;
138 } typed_val_decfloat;
139 struct symbol *sym;
140 struct type *tval;
141 struct stoken sval;
142 struct ttype tsym;
143 struct symtoken ssym;
144 int voidval;
145 struct block *bval;
146 enum exp_opcode opcode;
147 struct internalvar *ivar;
148
149 struct type **tvec;
150 int *ivec;
151 }
152
153 %{
154 /* YYSTYPE gets defined by %union */
155 static int parse_number (char *, int, int, YYSTYPE *);
156 %}
157
158 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
159 %type <lval> rcurly
160 %type <tval> type typebase qualified_type
161 %type <tvec> nonempty_typelist
162 /* %type <bval> block */
163
164 /* Fancy type parsing. */
165 %type <voidval> func_mod direct_abs_decl abs_decl
166 %type <tval> ptype
167 %type <lval> array_mod
168
169 %token <typed_val_int> INT
170 %token <typed_val_float> FLOAT
171 %token <typed_val_decfloat> DECFLOAT
172
173 /* Both NAME and TYPENAME tokens represent symbols in the input,
174 and both convey their data as strings.
175 But a TYPENAME is a string that happens to be defined as a typedef
176 or builtin type name (such as int or char)
177 and a NAME is any other symbol.
178 Contexts where this distinction is not important can use the
179 nonterminal "name", which matches either NAME or TYPENAME. */
180
181 %token <sval> STRING
182 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
183 %token <voidval> COMPLETE
184 %token <tsym> TYPENAME
185 %type <sval> name
186 %type <ssym> name_not_typename
187 %type <tsym> typename
188
189 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
190 but which would parse as a valid number in the current input radix.
191 E.g. "c" when input_radix==16. Depending on the parse, it will be
192 turned into a name or into a number. */
193
194 %token <ssym> NAME_OR_INT
195
196 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
197 %token TEMPLATE
198 %token ERROR
199
200 /* Special type cases, put in to allow the parser to distinguish different
201 legal basetypes. */
202 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
203
204 %token <voidval> VARIABLE
205
206 %token <opcode> ASSIGN_MODIFY
207
208 /* C++ */
209 %token TRUEKEYWORD
210 %token FALSEKEYWORD
211
212
213 %left ','
214 %left ABOVE_COMMA
215 %right '=' ASSIGN_MODIFY
216 %right '?'
217 %left OROR
218 %left ANDAND
219 %left '|'
220 %left '^'
221 %left '&'
222 %left EQUAL NOTEQUAL
223 %left '<' '>' LEQ GEQ
224 %left LSH RSH
225 %left '@'
226 %left '+' '-'
227 %left '*' '/' '%'
228 %right UNARY INCREMENT DECREMENT
229 %right ARROW '.' '[' '('
230 %token <ssym> BLOCKNAME
231 %token <bval> FILENAME
232 %type <bval> block
233 %left COLONCOLON
234
235 \f
236 %%
237
238 start : exp1
239 | type_exp
240 ;
241
242 type_exp: type
243 { write_exp_elt_opcode(OP_TYPE);
244 write_exp_elt_type($1);
245 write_exp_elt_opcode(OP_TYPE);}
246 ;
247
248 /* Expressions, including the comma operator. */
249 exp1 : exp
250 | exp1 ',' exp
251 { write_exp_elt_opcode (BINOP_COMMA); }
252 ;
253
254 /* Expressions, not including the comma operator. */
255 exp : '*' exp %prec UNARY
256 { write_exp_elt_opcode (UNOP_IND); }
257 ;
258
259 exp : '&' exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_ADDR); }
261 ;
262
263 exp : '-' exp %prec UNARY
264 { write_exp_elt_opcode (UNOP_NEG); }
265 ;
266
267 exp : '+' exp %prec UNARY
268 { write_exp_elt_opcode (UNOP_PLUS); }
269 ;
270
271 exp : '!' exp %prec UNARY
272 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
273 ;
274
275 exp : '~' exp %prec UNARY
276 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
277 ;
278
279 exp : INCREMENT exp %prec UNARY
280 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
281 ;
282
283 exp : DECREMENT exp %prec UNARY
284 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
285 ;
286
287 exp : exp INCREMENT %prec UNARY
288 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
289 ;
290
291 exp : exp DECREMENT %prec UNARY
292 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
293 ;
294
295 exp : SIZEOF exp %prec UNARY
296 { write_exp_elt_opcode (UNOP_SIZEOF); }
297 ;
298
299 exp : exp ARROW name
300 { write_exp_elt_opcode (STRUCTOP_PTR);
301 write_exp_string ($3);
302 write_exp_elt_opcode (STRUCTOP_PTR); }
303 ;
304
305 exp : exp ARROW name COMPLETE
306 { mark_struct_expression ();
307 write_exp_elt_opcode (STRUCTOP_PTR);
308 write_exp_string ($3);
309 write_exp_elt_opcode (STRUCTOP_PTR); }
310 ;
311
312 exp : exp ARROW COMPLETE
313 { struct stoken s;
314 mark_struct_expression ();
315 write_exp_elt_opcode (STRUCTOP_PTR);
316 s.ptr = "";
317 s.length = 0;
318 write_exp_string (s);
319 write_exp_elt_opcode (STRUCTOP_PTR); }
320 ;
321
322 exp : exp ARROW qualified_name
323 { /* exp->type::name becomes exp->*(&type::name) */
324 /* Note: this doesn't work if name is a
325 static member! FIXME */
326 write_exp_elt_opcode (UNOP_ADDR);
327 write_exp_elt_opcode (STRUCTOP_MPTR); }
328 ;
329
330 exp : exp ARROW '*' exp
331 { write_exp_elt_opcode (STRUCTOP_MPTR); }
332 ;
333
334 exp : exp '.' name
335 { write_exp_elt_opcode (STRUCTOP_STRUCT);
336 write_exp_string ($3);
337 write_exp_elt_opcode (STRUCTOP_STRUCT); }
338 ;
339
340 exp : exp '.' name COMPLETE
341 { mark_struct_expression ();
342 write_exp_elt_opcode (STRUCTOP_STRUCT);
343 write_exp_string ($3);
344 write_exp_elt_opcode (STRUCTOP_STRUCT); }
345 ;
346
347 exp : exp '.' COMPLETE
348 { struct stoken s;
349 mark_struct_expression ();
350 write_exp_elt_opcode (STRUCTOP_STRUCT);
351 s.ptr = "";
352 s.length = 0;
353 write_exp_string (s);
354 write_exp_elt_opcode (STRUCTOP_STRUCT); }
355 ;
356
357 exp : exp '.' qualified_name
358 { /* exp.type::name becomes exp.*(&type::name) */
359 /* Note: this doesn't work if name is a
360 static member! FIXME */
361 write_exp_elt_opcode (UNOP_ADDR);
362 write_exp_elt_opcode (STRUCTOP_MEMBER); }
363 ;
364
365 exp : exp '.' '*' exp
366 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
367 ;
368
369 exp : exp '[' exp1 ']'
370 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
371 ;
372
373 exp : exp '('
374 /* This is to save the value of arglist_len
375 being accumulated by an outer function call. */
376 { start_arglist (); }
377 arglist ')' %prec ARROW
378 { write_exp_elt_opcode (OP_FUNCALL);
379 write_exp_elt_longcst ((LONGEST) end_arglist ());
380 write_exp_elt_opcode (OP_FUNCALL); }
381 ;
382
383 lcurly : '{'
384 { start_arglist (); }
385 ;
386
387 arglist :
388 ;
389
390 arglist : exp
391 { arglist_len = 1; }
392 ;
393
394 arglist : arglist ',' exp %prec ABOVE_COMMA
395 { arglist_len++; }
396 ;
397
398 rcurly : '}'
399 { $$ = end_arglist () - 1; }
400 ;
401 exp : lcurly arglist rcurly %prec ARROW
402 { write_exp_elt_opcode (OP_ARRAY);
403 write_exp_elt_longcst ((LONGEST) 0);
404 write_exp_elt_longcst ((LONGEST) $3);
405 write_exp_elt_opcode (OP_ARRAY); }
406 ;
407
408 exp : lcurly type rcurly exp %prec UNARY
409 { write_exp_elt_opcode (UNOP_MEMVAL);
410 write_exp_elt_type ($2);
411 write_exp_elt_opcode (UNOP_MEMVAL); }
412 ;
413
414 exp : '(' type ')' exp %prec UNARY
415 { write_exp_elt_opcode (UNOP_CAST);
416 write_exp_elt_type ($2);
417 write_exp_elt_opcode (UNOP_CAST); }
418 ;
419
420 exp : '(' exp1 ')'
421 { }
422 ;
423
424 /* Binary operators in order of decreasing precedence. */
425
426 exp : exp '@' exp
427 { write_exp_elt_opcode (BINOP_REPEAT); }
428 ;
429
430 exp : exp '*' exp
431 { write_exp_elt_opcode (BINOP_MUL); }
432 ;
433
434 exp : exp '/' exp
435 { write_exp_elt_opcode (BINOP_DIV); }
436 ;
437
438 exp : exp '%' exp
439 { write_exp_elt_opcode (BINOP_REM); }
440 ;
441
442 exp : exp '+' exp
443 { write_exp_elt_opcode (BINOP_ADD); }
444 ;
445
446 exp : exp '-' exp
447 { write_exp_elt_opcode (BINOP_SUB); }
448 ;
449
450 exp : exp LSH exp
451 { write_exp_elt_opcode (BINOP_LSH); }
452 ;
453
454 exp : exp RSH exp
455 { write_exp_elt_opcode (BINOP_RSH); }
456 ;
457
458 exp : exp EQUAL exp
459 { write_exp_elt_opcode (BINOP_EQUAL); }
460 ;
461
462 exp : exp NOTEQUAL exp
463 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
464 ;
465
466 exp : exp LEQ exp
467 { write_exp_elt_opcode (BINOP_LEQ); }
468 ;
469
470 exp : exp GEQ exp
471 { write_exp_elt_opcode (BINOP_GEQ); }
472 ;
473
474 exp : exp '<' exp
475 { write_exp_elt_opcode (BINOP_LESS); }
476 ;
477
478 exp : exp '>' exp
479 { write_exp_elt_opcode (BINOP_GTR); }
480 ;
481
482 exp : exp '&' exp
483 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
484 ;
485
486 exp : exp '^' exp
487 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
488 ;
489
490 exp : exp '|' exp
491 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
492 ;
493
494 exp : exp ANDAND exp
495 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
496 ;
497
498 exp : exp OROR exp
499 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
500 ;
501
502 exp : exp '?' exp ':' exp %prec '?'
503 { write_exp_elt_opcode (TERNOP_COND); }
504 ;
505
506 exp : exp '=' exp
507 { write_exp_elt_opcode (BINOP_ASSIGN); }
508 ;
509
510 exp : exp ASSIGN_MODIFY exp
511 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
512 write_exp_elt_opcode ($2);
513 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
514 ;
515
516 exp : INT
517 { write_exp_elt_opcode (OP_LONG);
518 write_exp_elt_type ($1.type);
519 write_exp_elt_longcst ((LONGEST)($1.val));
520 write_exp_elt_opcode (OP_LONG); }
521 ;
522
523 exp : NAME_OR_INT
524 { YYSTYPE val;
525 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
526 write_exp_elt_opcode (OP_LONG);
527 write_exp_elt_type (val.typed_val_int.type);
528 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
529 write_exp_elt_opcode (OP_LONG);
530 }
531 ;
532
533
534 exp : FLOAT
535 { write_exp_elt_opcode (OP_DOUBLE);
536 write_exp_elt_type ($1.type);
537 write_exp_elt_dblcst ($1.dval);
538 write_exp_elt_opcode (OP_DOUBLE); }
539 ;
540
541 exp : DECFLOAT
542 { write_exp_elt_opcode (OP_DECFLOAT);
543 write_exp_elt_type ($1.type);
544 write_exp_elt_decfloatcst ($1.val);
545 write_exp_elt_opcode (OP_DECFLOAT); }
546 ;
547
548 exp : variable
549 ;
550
551 exp : VARIABLE
552 /* Already written by write_dollar_variable. */
553 ;
554
555 exp : SIZEOF '(' type ')' %prec UNARY
556 { write_exp_elt_opcode (OP_LONG);
557 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_int);
558 CHECK_TYPEDEF ($3);
559 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
560 write_exp_elt_opcode (OP_LONG); }
561 ;
562
563 exp : STRING
564 { /* C strings are converted into array constants with
565 an explicit null byte added at the end. Thus
566 the array upper bound is the string length.
567 There is no such thing in C as a completely empty
568 string. */
569 char *sp = $1.ptr; int count = $1.length;
570 while (count-- > 0)
571 {
572 write_exp_elt_opcode (OP_LONG);
573 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
574 write_exp_elt_longcst ((LONGEST)(*sp++));
575 write_exp_elt_opcode (OP_LONG);
576 }
577 write_exp_elt_opcode (OP_LONG);
578 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
579 write_exp_elt_longcst ((LONGEST)'\0');
580 write_exp_elt_opcode (OP_LONG);
581 write_exp_elt_opcode (OP_ARRAY);
582 write_exp_elt_longcst ((LONGEST) 0);
583 write_exp_elt_longcst ((LONGEST) ($1.length));
584 write_exp_elt_opcode (OP_ARRAY); }
585 ;
586
587 /* C++. */
588 exp : TRUEKEYWORD
589 { write_exp_elt_opcode (OP_LONG);
590 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
591 write_exp_elt_longcst ((LONGEST) 1);
592 write_exp_elt_opcode (OP_LONG); }
593 ;
594
595 exp : FALSEKEYWORD
596 { write_exp_elt_opcode (OP_LONG);
597 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
598 write_exp_elt_longcst ((LONGEST) 0);
599 write_exp_elt_opcode (OP_LONG); }
600 ;
601
602 /* end of C++. */
603
604 block : BLOCKNAME
605 {
606 if ($1.sym)
607 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
608 else
609 error ("No file or function \"%s\".",
610 copy_name ($1.stoken));
611 }
612 | FILENAME
613 {
614 $$ = $1;
615 }
616 ;
617
618 block : block COLONCOLON name
619 { struct symbol *tem
620 = lookup_symbol (copy_name ($3), $1,
621 VAR_DOMAIN, (int *) NULL);
622 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
623 error ("No function \"%s\" in specified context.",
624 copy_name ($3));
625 $$ = SYMBOL_BLOCK_VALUE (tem); }
626 ;
627
628 variable: block COLONCOLON name
629 { struct symbol *sym;
630 sym = lookup_symbol (copy_name ($3), $1,
631 VAR_DOMAIN, (int *) NULL);
632 if (sym == 0)
633 error ("No symbol \"%s\" in specified context.",
634 copy_name ($3));
635
636 write_exp_elt_opcode (OP_VAR_VALUE);
637 /* block_found is set by lookup_symbol. */
638 write_exp_elt_block (block_found);
639 write_exp_elt_sym (sym);
640 write_exp_elt_opcode (OP_VAR_VALUE); }
641 ;
642
643 qualified_name: typebase COLONCOLON name
644 {
645 struct type *type = $1;
646 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
647 && TYPE_CODE (type) != TYPE_CODE_UNION
648 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
649 error ("`%s' is not defined as an aggregate type.",
650 TYPE_NAME (type));
651
652 write_exp_elt_opcode (OP_SCOPE);
653 write_exp_elt_type (type);
654 write_exp_string ($3);
655 write_exp_elt_opcode (OP_SCOPE);
656 }
657 | typebase COLONCOLON '~' name
658 {
659 struct type *type = $1;
660 struct stoken tmp_token;
661 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
662 && TYPE_CODE (type) != TYPE_CODE_UNION
663 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
664 error ("`%s' is not defined as an aggregate type.",
665 TYPE_NAME (type));
666
667 tmp_token.ptr = (char*) alloca ($4.length + 2);
668 tmp_token.length = $4.length + 1;
669 tmp_token.ptr[0] = '~';
670 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
671 tmp_token.ptr[tmp_token.length] = 0;
672
673 /* Check for valid destructor name. */
674 destructor_name_p (tmp_token.ptr, type);
675 write_exp_elt_opcode (OP_SCOPE);
676 write_exp_elt_type (type);
677 write_exp_string (tmp_token);
678 write_exp_elt_opcode (OP_SCOPE);
679 }
680 ;
681
682 variable: qualified_name
683 | COLONCOLON name
684 {
685 char *name = copy_name ($2);
686 struct symbol *sym;
687 struct minimal_symbol *msymbol;
688
689 sym =
690 lookup_symbol (name, (const struct block *) NULL,
691 VAR_DOMAIN, (int *) NULL);
692 if (sym)
693 {
694 write_exp_elt_opcode (OP_VAR_VALUE);
695 write_exp_elt_block (NULL);
696 write_exp_elt_sym (sym);
697 write_exp_elt_opcode (OP_VAR_VALUE);
698 break;
699 }
700
701 msymbol = lookup_minimal_symbol (name, NULL, NULL);
702 if (msymbol != NULL)
703 write_exp_msymbol (msymbol);
704 else if (!have_full_symbols () && !have_partial_symbols ())
705 error ("No symbol table is loaded. Use the \"file\" command.");
706 else
707 error ("No symbol \"%s\" in current context.", name);
708 }
709 ;
710
711 variable: name_not_typename
712 { struct symbol *sym = $1.sym;
713
714 if (sym)
715 {
716 if (symbol_read_needs_frame (sym))
717 {
718 if (innermost_block == 0 ||
719 contained_in (block_found,
720 innermost_block))
721 innermost_block = block_found;
722 }
723
724 write_exp_elt_opcode (OP_VAR_VALUE);
725 /* We want to use the selected frame, not
726 another more inner frame which happens to
727 be in the same block. */
728 write_exp_elt_block (NULL);
729 write_exp_elt_sym (sym);
730 write_exp_elt_opcode (OP_VAR_VALUE);
731 }
732 else if ($1.is_a_field_of_this)
733 {
734 /* C++: it hangs off of `this'. Must
735 not inadvertently convert from a method call
736 to data ref. */
737 if (innermost_block == 0 ||
738 contained_in (block_found, innermost_block))
739 innermost_block = block_found;
740 write_exp_elt_opcode (OP_THIS);
741 write_exp_elt_opcode (OP_THIS);
742 write_exp_elt_opcode (STRUCTOP_PTR);
743 write_exp_string ($1.stoken);
744 write_exp_elt_opcode (STRUCTOP_PTR);
745 }
746 else
747 {
748 struct minimal_symbol *msymbol;
749 char *arg = copy_name ($1.stoken);
750
751 msymbol =
752 lookup_minimal_symbol (arg, NULL, NULL);
753 if (msymbol != NULL)
754 write_exp_msymbol (msymbol);
755 else if (!have_full_symbols () && !have_partial_symbols ())
756 error ("No symbol table is loaded. Use the \"file\" command.");
757 else
758 error ("No symbol \"%s\" in current context.",
759 copy_name ($1.stoken));
760 }
761 }
762 ;
763
764 space_identifier : '@' NAME
765 { push_type_address_space (copy_name ($2.stoken));
766 push_type (tp_space_identifier);
767 }
768 ;
769
770 const_or_volatile: const_or_volatile_noopt
771 |
772 ;
773
774 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
775 ;
776
777 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
778 | const_or_volatile_noopt
779 ;
780
781 const_or_volatile_or_space_identifier:
782 const_or_volatile_or_space_identifier_noopt
783 |
784 ;
785
786 abs_decl: '*'
787 { push_type (tp_pointer); $$ = 0; }
788 | '*' abs_decl
789 { push_type (tp_pointer); $$ = $2; }
790 | '&'
791 { push_type (tp_reference); $$ = 0; }
792 | '&' abs_decl
793 { push_type (tp_reference); $$ = $2; }
794 | direct_abs_decl
795 ;
796
797 direct_abs_decl: '(' abs_decl ')'
798 { $$ = $2; }
799 | direct_abs_decl array_mod
800 {
801 push_type_int ($2);
802 push_type (tp_array);
803 }
804 | array_mod
805 {
806 push_type_int ($1);
807 push_type (tp_array);
808 $$ = 0;
809 }
810
811 | direct_abs_decl func_mod
812 { push_type (tp_function); }
813 | func_mod
814 { push_type (tp_function); }
815 ;
816
817 array_mod: '[' ']'
818 { $$ = -1; }
819 | '[' INT ']'
820 { $$ = $2.val; }
821 ;
822
823 func_mod: '(' ')'
824 { $$ = 0; }
825 | '(' nonempty_typelist ')'
826 { free ($2); $$ = 0; }
827 ;
828
829 /* We used to try to recognize pointer to member types here, but
830 that didn't work (shift/reduce conflicts meant that these rules never
831 got executed). The problem is that
832 int (foo::bar::baz::bizzle)
833 is a function type but
834 int (foo::bar::baz::bizzle::*)
835 is a pointer to member type. Stroustrup loses again! */
836
837 type : ptype
838 ;
839
840 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
841 : TYPENAME
842 { $$ = $1.type; }
843 | INT_KEYWORD
844 { $$ = builtin_type (current_gdbarch)->builtin_int; }
845 | LONG
846 { $$ = builtin_type (current_gdbarch)->builtin_long; }
847 | SHORT
848 { $$ = builtin_type (current_gdbarch)->builtin_short; }
849 | LONG INT_KEYWORD
850 { $$ = builtin_type (current_gdbarch)->builtin_long; }
851 | LONG SIGNED_KEYWORD INT_KEYWORD
852 { $$ = builtin_type (current_gdbarch)->builtin_long; }
853 | LONG SIGNED_KEYWORD
854 { $$ = builtin_type (current_gdbarch)->builtin_long; }
855 | SIGNED_KEYWORD LONG INT_KEYWORD
856 { $$ = builtin_type (current_gdbarch)->builtin_long; }
857 | UNSIGNED LONG INT_KEYWORD
858 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
859 | LONG UNSIGNED INT_KEYWORD
860 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
861 | LONG UNSIGNED
862 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
863 | LONG LONG
864 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
865 | LONG LONG INT_KEYWORD
866 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
867 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
868 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
869 | LONG LONG SIGNED_KEYWORD
870 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
871 | SIGNED_KEYWORD LONG LONG
872 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
873 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
874 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
875 | UNSIGNED LONG LONG
876 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
877 | UNSIGNED LONG LONG INT_KEYWORD
878 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
879 | LONG LONG UNSIGNED
880 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
881 | LONG LONG UNSIGNED INT_KEYWORD
882 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
883 | SHORT INT_KEYWORD
884 { $$ = builtin_type (current_gdbarch)->builtin_short; }
885 | SHORT SIGNED_KEYWORD INT_KEYWORD
886 { $$ = builtin_type (current_gdbarch)->builtin_short; }
887 | SHORT SIGNED_KEYWORD
888 { $$ = builtin_type (current_gdbarch)->builtin_short; }
889 | UNSIGNED SHORT INT_KEYWORD
890 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
891 | SHORT UNSIGNED
892 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
893 | SHORT UNSIGNED INT_KEYWORD
894 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
895 | DOUBLE_KEYWORD
896 { $$ = builtin_type (current_gdbarch)->builtin_double; }
897 | LONG DOUBLE_KEYWORD
898 { $$ = builtin_type (current_gdbarch)->builtin_long_double; }
899 | STRUCT name
900 { $$ = lookup_struct (copy_name ($2),
901 expression_context_block); }
902 | CLASS name
903 { $$ = lookup_struct (copy_name ($2),
904 expression_context_block); }
905 | UNION name
906 { $$ = lookup_union (copy_name ($2),
907 expression_context_block); }
908 | ENUM name
909 { $$ = lookup_enum (copy_name ($2),
910 expression_context_block); }
911 | UNSIGNED typename
912 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
913 | UNSIGNED
914 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_int; }
915 | SIGNED_KEYWORD typename
916 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
917 | SIGNED_KEYWORD
918 { $$ = builtin_type (current_gdbarch)->builtin_int; }
919 /* It appears that this rule for templates is never
920 reduced; template recognition happens by lookahead
921 in the token processing code in yylex. */
922 | TEMPLATE name '<' type '>'
923 { $$ = lookup_template_type(copy_name($2), $4,
924 expression_context_block);
925 }
926 | const_or_volatile_or_space_identifier_noopt typebase
927 { $$ = follow_types ($2); }
928 | typebase const_or_volatile_or_space_identifier_noopt
929 { $$ = follow_types ($1); }
930 | qualified_type
931 ;
932
933 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
934 reduce-reduce conflicts, because the parser doesn't know whether or
935 not to use qualified_name or qualified_type: the rules are
936 identical. If the parser is parsing 'A::B::x', then, when it sees
937 the second '::', it knows that the expression to the left of it has
938 to be a type, so it uses qualified_type. But if it is parsing just
939 'A::B', then it doesn't have any way of knowing which rule to use,
940 so there's a reduce-reduce conflict; it picks qualified_name, since
941 that occurs earlier in this file than qualified_type.
942
943 There's no good way to fix this with the grammar as it stands; as
944 far as I can tell, some of the problems arise from ambiguities that
945 GDB introduces ('start' can be either an expression or a type), but
946 some of it is inherent to the nature of C++ (you want to treat the
947 input "(FOO)" fairly differently depending on whether FOO is an
948 expression or a type, and if FOO is a complex expression, this can
949 be hard to determine at the right time). Fortunately, it works
950 pretty well in most cases. For example, if you do 'ptype A::B',
951 where A::B is a nested type, then the parser will mistakenly
952 misidentify it as an expression; but evaluate_subexp will get
953 called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
954 will work out anyways. But there are situations where the parser
955 will get confused: the most common one that I've run into is when
956 you want to do
957
958 print *((A::B *) x)"
959
960 where the parser doesn't realize that A::B has to be a type until
961 it hits the first right paren, at which point it's too late. (The
962 workaround is to type "print *(('A::B' *) x)" instead.) (And
963 another solution is to fix our symbol-handling code so that the
964 user never wants to type something like that in the first place,
965 because we get all the types right without the user's help!)
966
967 Perhaps we could fix this by making the lexer smarter. Some of
968 this functionality used to be in the lexer, but in a way that
969 worked even less well than the current solution: that attempt
970 involved having the parser sometimes handle '::' and having the
971 lexer sometimes handle it, and without a clear division of
972 responsibility, it quickly degenerated into a big mess. Probably
973 the eventual correct solution will give more of a role to the lexer
974 (ideally via code that is shared between the lexer and
975 decode_line_1), but I'm not holding my breath waiting for somebody
976 to get around to cleaning this up... */
977
978 qualified_type: typebase COLONCOLON name
979 {
980 struct type *type = $1;
981 struct type *new_type;
982 char *ncopy = alloca ($3.length + 1);
983
984 memcpy (ncopy, $3.ptr, $3.length);
985 ncopy[$3.length] = '\0';
986
987 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
988 && TYPE_CODE (type) != TYPE_CODE_UNION
989 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
990 error ("`%s' is not defined as an aggregate type.",
991 TYPE_NAME (type));
992
993 new_type = cp_lookup_nested_type (type, ncopy,
994 expression_context_block);
995 if (new_type == NULL)
996 error ("No type \"%s\" within class or namespace \"%s\".",
997 ncopy, TYPE_NAME (type));
998
999 $$ = new_type;
1000 }
1001 ;
1002
1003 typename: TYPENAME
1004 | INT_KEYWORD
1005 {
1006 $$.stoken.ptr = "int";
1007 $$.stoken.length = 3;
1008 $$.type = builtin_type (current_gdbarch)->builtin_int;
1009 }
1010 | LONG
1011 {
1012 $$.stoken.ptr = "long";
1013 $$.stoken.length = 4;
1014 $$.type = builtin_type (current_gdbarch)->builtin_long;
1015 }
1016 | SHORT
1017 {
1018 $$.stoken.ptr = "short";
1019 $$.stoken.length = 5;
1020 $$.type = builtin_type (current_gdbarch)->builtin_short;
1021 }
1022 ;
1023
1024 nonempty_typelist
1025 : type
1026 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1027 $<ivec>$[0] = 1; /* Number of types in vector */
1028 $$[1] = $1;
1029 }
1030 | nonempty_typelist ',' type
1031 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1032 $$ = (struct type **) realloc ((char *) $1, len);
1033 $$[$<ivec>$[0]] = $3;
1034 }
1035 ;
1036
1037 ptype : typebase
1038 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1039 { $$ = follow_types ($1); }
1040 ;
1041
1042 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1043 | VOLATILE_KEYWORD CONST_KEYWORD
1044 ;
1045
1046 const_or_volatile_noopt: const_and_volatile
1047 { push_type (tp_const);
1048 push_type (tp_volatile);
1049 }
1050 | CONST_KEYWORD
1051 { push_type (tp_const); }
1052 | VOLATILE_KEYWORD
1053 { push_type (tp_volatile); }
1054 ;
1055
1056 name : NAME { $$ = $1.stoken; }
1057 | BLOCKNAME { $$ = $1.stoken; }
1058 | TYPENAME { $$ = $1.stoken; }
1059 | NAME_OR_INT { $$ = $1.stoken; }
1060 ;
1061
1062 name_not_typename : NAME
1063 | BLOCKNAME
1064 /* These would be useful if name_not_typename was useful, but it is just
1065 a fake for "variable", so these cause reduce/reduce conflicts because
1066 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1067 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1068 context where only a name could occur, this might be useful.
1069 | NAME_OR_INT
1070 */
1071 ;
1072
1073 %%
1074
1075 /* Take care of parsing a number (anything that starts with a digit).
1076 Set yylval and return the token type; update lexptr.
1077 LEN is the number of characters in it. */
1078
1079 /*** Needs some error checking for the float case ***/
1080
1081 static int
1082 parse_number (p, len, parsed_float, putithere)
1083 char *p;
1084 int len;
1085 int parsed_float;
1086 YYSTYPE *putithere;
1087 {
1088 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1089 here, and we do kind of silly things like cast to unsigned. */
1090 LONGEST n = 0;
1091 LONGEST prevn = 0;
1092 ULONGEST un;
1093
1094 int i = 0;
1095 int c;
1096 int base = input_radix;
1097 int unsigned_p = 0;
1098
1099 /* Number of "L" suffixes encountered. */
1100 int long_p = 0;
1101
1102 /* We have found a "L" or "U" suffix. */
1103 int found_suffix = 0;
1104
1105 ULONGEST high_bit;
1106 struct type *signed_type;
1107 struct type *unsigned_type;
1108
1109 if (parsed_float)
1110 {
1111 /* It's a float since it contains a point or an exponent. */
1112 char *s;
1113 int num; /* number of tokens scanned by scanf */
1114 char saved_char;
1115
1116 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1117 point. Return DECFLOAT. */
1118
1119 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1120 {
1121 p[len - 2] = '\0';
1122 putithere->typed_val_decfloat.type
1123 = builtin_type (current_gdbarch)->builtin_decfloat;
1124 decimal_from_string (putithere->typed_val_decfloat.val, 4, p);
1125 p[len - 2] = 'd';
1126 return DECFLOAT;
1127 }
1128
1129 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1130 {
1131 p[len - 2] = '\0';
1132 putithere->typed_val_decfloat.type
1133 = builtin_type (current_gdbarch)->builtin_decdouble;
1134 decimal_from_string (putithere->typed_val_decfloat.val, 8, p);
1135 p[len - 2] = 'd';
1136 return DECFLOAT;
1137 }
1138
1139 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1140 {
1141 p[len - 2] = '\0';
1142 putithere->typed_val_decfloat.type
1143 = builtin_type (current_gdbarch)->builtin_declong;
1144 decimal_from_string (putithere->typed_val_decfloat.val, 16, p);
1145 p[len - 2] = 'd';
1146 return DECFLOAT;
1147 }
1148
1149 s = malloc (len);
1150 saved_char = p[len];
1151 p[len] = 0; /* null-terminate the token */
1152 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
1153 &putithere->typed_val_float.dval, s);
1154 p[len] = saved_char; /* restore the input stream */
1155
1156 if (num == 1)
1157 putithere->typed_val_float.type =
1158 builtin_type (current_gdbarch)->builtin_double;
1159
1160 if (num == 2 )
1161 {
1162 /* See if it has any float suffix: 'f' for float, 'l' for long
1163 double. */
1164 if (!strcasecmp (s, "f"))
1165 putithere->typed_val_float.type =
1166 builtin_type (current_gdbarch)->builtin_float;
1167 else if (!strcasecmp (s, "l"))
1168 putithere->typed_val_float.type =
1169 builtin_type (current_gdbarch)->builtin_long_double;
1170 else
1171 {
1172 free (s);
1173 return ERROR;
1174 }
1175 }
1176
1177 free (s);
1178 return FLOAT;
1179 }
1180
1181 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1182 if (p[0] == '0')
1183 switch (p[1])
1184 {
1185 case 'x':
1186 case 'X':
1187 if (len >= 3)
1188 {
1189 p += 2;
1190 base = 16;
1191 len -= 2;
1192 }
1193 break;
1194
1195 case 't':
1196 case 'T':
1197 case 'd':
1198 case 'D':
1199 if (len >= 3)
1200 {
1201 p += 2;
1202 base = 10;
1203 len -= 2;
1204 }
1205 break;
1206
1207 default:
1208 base = 8;
1209 break;
1210 }
1211
1212 while (len-- > 0)
1213 {
1214 c = *p++;
1215 if (c >= 'A' && c <= 'Z')
1216 c += 'a' - 'A';
1217 if (c != 'l' && c != 'u')
1218 n *= base;
1219 if (c >= '0' && c <= '9')
1220 {
1221 if (found_suffix)
1222 return ERROR;
1223 n += i = c - '0';
1224 }
1225 else
1226 {
1227 if (base > 10 && c >= 'a' && c <= 'f')
1228 {
1229 if (found_suffix)
1230 return ERROR;
1231 n += i = c - 'a' + 10;
1232 }
1233 else if (c == 'l')
1234 {
1235 ++long_p;
1236 found_suffix = 1;
1237 }
1238 else if (c == 'u')
1239 {
1240 unsigned_p = 1;
1241 found_suffix = 1;
1242 }
1243 else
1244 return ERROR; /* Char not a digit */
1245 }
1246 if (i >= base)
1247 return ERROR; /* Invalid digit in this base */
1248
1249 /* Portably test for overflow (only works for nonzero values, so make
1250 a second check for zero). FIXME: Can't we just make n and prevn
1251 unsigned and avoid this? */
1252 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1253 unsigned_p = 1; /* Try something unsigned */
1254
1255 /* Portably test for unsigned overflow.
1256 FIXME: This check is wrong; for example it doesn't find overflow
1257 on 0x123456789 when LONGEST is 32 bits. */
1258 if (c != 'l' && c != 'u' && n != 0)
1259 {
1260 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1261 error ("Numeric constant too large.");
1262 }
1263 prevn = n;
1264 }
1265
1266 /* An integer constant is an int, a long, or a long long. An L
1267 suffix forces it to be long; an LL suffix forces it to be long
1268 long. If not forced to a larger size, it gets the first type of
1269 the above that it fits in. To figure out whether it fits, we
1270 shift it right and see whether anything remains. Note that we
1271 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1272 operation, because many compilers will warn about such a shift
1273 (which always produces a zero result). Sometimes gdbarch_int_bit
1274 or gdbarch_long_bit will be that big, sometimes not. To deal with
1275 the case where it is we just always shift the value more than
1276 once, with fewer bits each time. */
1277
1278 un = (ULONGEST)n >> 2;
1279 if (long_p == 0
1280 && (un >> (gdbarch_int_bit (current_gdbarch) - 2)) == 0)
1281 {
1282 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (current_gdbarch) - 1);
1283
1284 /* A large decimal (not hex or octal) constant (between INT_MAX
1285 and UINT_MAX) is a long or unsigned long, according to ANSI,
1286 never an unsigned int, but this code treats it as unsigned
1287 int. This probably should be fixed. GCC gives a warning on
1288 such constants. */
1289
1290 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_int;
1291 signed_type = builtin_type (current_gdbarch)->builtin_int;
1292 }
1293 else if (long_p <= 1
1294 && (un >> (gdbarch_long_bit (current_gdbarch) - 2)) == 0)
1295 {
1296 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (current_gdbarch) - 1);
1297 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long;
1298 signed_type = builtin_type (current_gdbarch)->builtin_long;
1299 }
1300 else
1301 {
1302 int shift;
1303 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1304 < gdbarch_long_long_bit (current_gdbarch))
1305 /* A long long does not fit in a LONGEST. */
1306 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1307 else
1308 shift = (gdbarch_long_long_bit (current_gdbarch) - 1);
1309 high_bit = (ULONGEST) 1 << shift;
1310 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long_long;
1311 signed_type = builtin_type (current_gdbarch)->builtin_long_long;
1312 }
1313
1314 putithere->typed_val_int.val = n;
1315
1316 /* If the high bit of the worked out type is set then this number
1317 has to be unsigned. */
1318
1319 if (unsigned_p || (n & high_bit))
1320 {
1321 putithere->typed_val_int.type = unsigned_type;
1322 }
1323 else
1324 {
1325 putithere->typed_val_int.type = signed_type;
1326 }
1327
1328 return INT;
1329 }
1330
1331 struct token
1332 {
1333 char *operator;
1334 int token;
1335 enum exp_opcode opcode;
1336 };
1337
1338 static const struct token tokentab3[] =
1339 {
1340 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1341 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1342 };
1343
1344 static const struct token tokentab2[] =
1345 {
1346 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1347 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1348 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1349 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1350 {"%=", ASSIGN_MODIFY, BINOP_REM},
1351 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1352 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1353 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1354 {"++", INCREMENT, BINOP_END},
1355 {"--", DECREMENT, BINOP_END},
1356 {"->", ARROW, BINOP_END},
1357 {"&&", ANDAND, BINOP_END},
1358 {"||", OROR, BINOP_END},
1359 {"::", COLONCOLON, BINOP_END},
1360 {"<<", LSH, BINOP_END},
1361 {">>", RSH, BINOP_END},
1362 {"==", EQUAL, BINOP_END},
1363 {"!=", NOTEQUAL, BINOP_END},
1364 {"<=", LEQ, BINOP_END},
1365 {">=", GEQ, BINOP_END}
1366 };
1367
1368 /* This is set if a NAME token appeared at the very end of the input
1369 string, with no whitespace separating the name from the EOF. This
1370 is used only when parsing to do field name completion. */
1371 static int saw_name_at_eof;
1372
1373 /* This is set if the previously-returned token was a structure
1374 operator -- either '.' or ARROW. This is used only when parsing to
1375 do field name completion. */
1376 static int last_was_structop;
1377
1378 /* Read one token, getting characters through lexptr. */
1379
1380 static int
1381 yylex ()
1382 {
1383 int c;
1384 int namelen;
1385 unsigned int i;
1386 char *tokstart;
1387 char *tokptr;
1388 int tempbufindex;
1389 static char *tempbuf;
1390 static int tempbufsize;
1391 char * token_string = NULL;
1392 int class_prefix = 0;
1393 int saw_structop = last_was_structop;
1394
1395 last_was_structop = 0;
1396
1397 retry:
1398
1399 /* Check if this is a macro invocation that we need to expand. */
1400 if (! scanning_macro_expansion ())
1401 {
1402 char *expanded = macro_expand_next (&lexptr,
1403 expression_macro_lookup_func,
1404 expression_macro_lookup_baton);
1405
1406 if (expanded)
1407 scan_macro_expansion (expanded);
1408 }
1409
1410 prev_lexptr = lexptr;
1411
1412 tokstart = lexptr;
1413 /* See if it is a special token of length 3. */
1414 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1415 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1416 {
1417 lexptr += 3;
1418 yylval.opcode = tokentab3[i].opcode;
1419 return tokentab3[i].token;
1420 }
1421
1422 /* See if it is a special token of length 2. */
1423 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1424 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1425 {
1426 lexptr += 2;
1427 yylval.opcode = tokentab2[i].opcode;
1428 if (in_parse_field && tokentab2[i].token == ARROW)
1429 last_was_structop = 1;
1430 return tokentab2[i].token;
1431 }
1432
1433 switch (c = *tokstart)
1434 {
1435 case 0:
1436 /* If we were just scanning the result of a macro expansion,
1437 then we need to resume scanning the original text.
1438 If we're parsing for field name completion, and the previous
1439 token allows such completion, return a COMPLETE token.
1440 Otherwise, we were already scanning the original text, and
1441 we're really done. */
1442 if (scanning_macro_expansion ())
1443 {
1444 finished_macro_expansion ();
1445 goto retry;
1446 }
1447 else if (saw_name_at_eof)
1448 {
1449 saw_name_at_eof = 0;
1450 return COMPLETE;
1451 }
1452 else if (saw_structop)
1453 return COMPLETE;
1454 else
1455 return 0;
1456
1457 case ' ':
1458 case '\t':
1459 case '\n':
1460 lexptr++;
1461 goto retry;
1462
1463 case '\'':
1464 /* We either have a character constant ('0' or '\177' for example)
1465 or we have a quoted symbol reference ('foo(int,int)' in C++
1466 for example). */
1467 lexptr++;
1468 c = *lexptr++;
1469 if (c == '\\')
1470 c = parse_escape (&lexptr);
1471 else if (c == '\'')
1472 error ("Empty character constant.");
1473 else if (! host_char_to_target (c, &c))
1474 {
1475 int toklen = lexptr - tokstart + 1;
1476 char *tok = alloca (toklen + 1);
1477 memcpy (tok, tokstart, toklen);
1478 tok[toklen] = '\0';
1479 error ("There is no character corresponding to %s in the target "
1480 "character set `%s'.", tok, target_charset ());
1481 }
1482
1483 yylval.typed_val_int.val = c;
1484 yylval.typed_val_int.type = builtin_type (current_gdbarch)->builtin_char;
1485
1486 c = *lexptr++;
1487 if (c != '\'')
1488 {
1489 namelen = skip_quoted (tokstart) - tokstart;
1490 if (namelen > 2)
1491 {
1492 lexptr = tokstart + namelen;
1493 if (lexptr[-1] != '\'')
1494 error ("Unmatched single quote.");
1495 namelen -= 2;
1496 tokstart++;
1497 goto tryname;
1498 }
1499 error ("Invalid character constant.");
1500 }
1501 return INT;
1502
1503 case '(':
1504 paren_depth++;
1505 lexptr++;
1506 return c;
1507
1508 case ')':
1509 if (paren_depth == 0)
1510 return 0;
1511 paren_depth--;
1512 lexptr++;
1513 return c;
1514
1515 case ',':
1516 if (comma_terminates
1517 && paren_depth == 0
1518 && ! scanning_macro_expansion ())
1519 return 0;
1520 lexptr++;
1521 return c;
1522
1523 case '.':
1524 /* Might be a floating point number. */
1525 if (lexptr[1] < '0' || lexptr[1] > '9')
1526 {
1527 if (in_parse_field)
1528 last_was_structop = 1;
1529 goto symbol; /* Nope, must be a symbol. */
1530 }
1531 /* FALL THRU into number case. */
1532
1533 case '0':
1534 case '1':
1535 case '2':
1536 case '3':
1537 case '4':
1538 case '5':
1539 case '6':
1540 case '7':
1541 case '8':
1542 case '9':
1543 {
1544 /* It's a number. */
1545 int got_dot = 0, got_e = 0, toktype;
1546 char *p = tokstart;
1547 int hex = input_radix > 10;
1548
1549 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1550 {
1551 p += 2;
1552 hex = 1;
1553 }
1554 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1555 {
1556 p += 2;
1557 hex = 0;
1558 }
1559
1560 for (;; ++p)
1561 {
1562 /* This test includes !hex because 'e' is a valid hex digit
1563 and thus does not indicate a floating point number when
1564 the radix is hex. */
1565 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1566 got_dot = got_e = 1;
1567 /* This test does not include !hex, because a '.' always indicates
1568 a decimal floating point number regardless of the radix. */
1569 else if (!got_dot && *p == '.')
1570 got_dot = 1;
1571 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1572 && (*p == '-' || *p == '+'))
1573 /* This is the sign of the exponent, not the end of the
1574 number. */
1575 continue;
1576 /* We will take any letters or digits. parse_number will
1577 complain if past the radix, or if L or U are not final. */
1578 else if ((*p < '0' || *p > '9')
1579 && ((*p < 'a' || *p > 'z')
1580 && (*p < 'A' || *p > 'Z')))
1581 break;
1582 }
1583 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1584 if (toktype == ERROR)
1585 {
1586 char *err_copy = (char *) alloca (p - tokstart + 1);
1587
1588 memcpy (err_copy, tokstart, p - tokstart);
1589 err_copy[p - tokstart] = 0;
1590 error ("Invalid number \"%s\".", err_copy);
1591 }
1592 lexptr = p;
1593 return toktype;
1594 }
1595
1596 case '+':
1597 case '-':
1598 case '*':
1599 case '/':
1600 case '%':
1601 case '|':
1602 case '&':
1603 case '^':
1604 case '~':
1605 case '!':
1606 case '@':
1607 case '<':
1608 case '>':
1609 case '[':
1610 case ']':
1611 case '?':
1612 case ':':
1613 case '=':
1614 case '{':
1615 case '}':
1616 symbol:
1617 lexptr++;
1618 return c;
1619
1620 case '"':
1621
1622 /* Build the gdb internal form of the input string in tempbuf,
1623 translating any standard C escape forms seen. Note that the
1624 buffer is null byte terminated *only* for the convenience of
1625 debugging gdb itself and printing the buffer contents when
1626 the buffer contains no embedded nulls. Gdb does not depend
1627 upon the buffer being null byte terminated, it uses the length
1628 string instead. This allows gdb to handle C strings (as well
1629 as strings in other languages) with embedded null bytes */
1630
1631 tokptr = ++tokstart;
1632 tempbufindex = 0;
1633
1634 do {
1635 char *char_start_pos = tokptr;
1636
1637 /* Grow the static temp buffer if necessary, including allocating
1638 the first one on demand. */
1639 if (tempbufindex + 1 >= tempbufsize)
1640 {
1641 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1642 }
1643 switch (*tokptr)
1644 {
1645 case '\0':
1646 case '"':
1647 /* Do nothing, loop will terminate. */
1648 break;
1649 case '\\':
1650 tokptr++;
1651 c = parse_escape (&tokptr);
1652 if (c == -1)
1653 {
1654 continue;
1655 }
1656 tempbuf[tempbufindex++] = c;
1657 break;
1658 default:
1659 c = *tokptr++;
1660 if (! host_char_to_target (c, &c))
1661 {
1662 int len = tokptr - char_start_pos;
1663 char *copy = alloca (len + 1);
1664 memcpy (copy, char_start_pos, len);
1665 copy[len] = '\0';
1666
1667 error ("There is no character corresponding to `%s' "
1668 "in the target character set `%s'.",
1669 copy, target_charset ());
1670 }
1671 tempbuf[tempbufindex++] = c;
1672 break;
1673 }
1674 } while ((*tokptr != '"') && (*tokptr != '\0'));
1675 if (*tokptr++ != '"')
1676 {
1677 error ("Unterminated string in expression.");
1678 }
1679 tempbuf[tempbufindex] = '\0'; /* See note above */
1680 yylval.sval.ptr = tempbuf;
1681 yylval.sval.length = tempbufindex;
1682 lexptr = tokptr;
1683 return (STRING);
1684 }
1685
1686 if (!(c == '_' || c == '$'
1687 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1688 /* We must have come across a bad character (e.g. ';'). */
1689 error ("Invalid character '%c' in expression.", c);
1690
1691 /* It's a name. See how long it is. */
1692 namelen = 0;
1693 for (c = tokstart[namelen];
1694 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1695 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1696 {
1697 /* Template parameter lists are part of the name.
1698 FIXME: This mishandles `print $a<4&&$a>3'. */
1699
1700 if (c == '<')
1701 {
1702 /* Scan ahead to get rest of the template specification. Note
1703 that we look ahead only when the '<' adjoins non-whitespace
1704 characters; for comparison expressions, e.g. "a < b > c",
1705 there must be spaces before the '<', etc. */
1706
1707 char * p = find_template_name_end (tokstart + namelen);
1708 if (p)
1709 namelen = p - tokstart;
1710 break;
1711 }
1712 c = tokstart[++namelen];
1713 }
1714
1715 /* The token "if" terminates the expression and is NOT removed from
1716 the input stream. It doesn't count if it appears in the
1717 expansion of a macro. */
1718 if (namelen == 2
1719 && tokstart[0] == 'i'
1720 && tokstart[1] == 'f'
1721 && ! scanning_macro_expansion ())
1722 {
1723 return 0;
1724 }
1725
1726 lexptr += namelen;
1727
1728 tryname:
1729
1730 /* Catch specific keywords. Should be done with a data structure. */
1731 switch (namelen)
1732 {
1733 case 8:
1734 if (strncmp (tokstart, "unsigned", 8) == 0)
1735 return UNSIGNED;
1736 if (current_language->la_language == language_cplus
1737 && strncmp (tokstart, "template", 8) == 0)
1738 return TEMPLATE;
1739 if (strncmp (tokstart, "volatile", 8) == 0)
1740 return VOLATILE_KEYWORD;
1741 break;
1742 case 6:
1743 if (strncmp (tokstart, "struct", 6) == 0)
1744 return STRUCT;
1745 if (strncmp (tokstart, "signed", 6) == 0)
1746 return SIGNED_KEYWORD;
1747 if (strncmp (tokstart, "sizeof", 6) == 0)
1748 return SIZEOF;
1749 if (strncmp (tokstart, "double", 6) == 0)
1750 return DOUBLE_KEYWORD;
1751 break;
1752 case 5:
1753 if (current_language->la_language == language_cplus)
1754 {
1755 if (strncmp (tokstart, "false", 5) == 0)
1756 return FALSEKEYWORD;
1757 if (strncmp (tokstart, "class", 5) == 0)
1758 return CLASS;
1759 }
1760 if (strncmp (tokstart, "union", 5) == 0)
1761 return UNION;
1762 if (strncmp (tokstart, "short", 5) == 0)
1763 return SHORT;
1764 if (strncmp (tokstart, "const", 5) == 0)
1765 return CONST_KEYWORD;
1766 break;
1767 case 4:
1768 if (strncmp (tokstart, "enum", 4) == 0)
1769 return ENUM;
1770 if (strncmp (tokstart, "long", 4) == 0)
1771 return LONG;
1772 if (current_language->la_language == language_cplus)
1773 {
1774 if (strncmp (tokstart, "true", 4) == 0)
1775 return TRUEKEYWORD;
1776 }
1777 break;
1778 case 3:
1779 if (strncmp (tokstart, "int", 3) == 0)
1780 return INT_KEYWORD;
1781 break;
1782 default:
1783 break;
1784 }
1785
1786 yylval.sval.ptr = tokstart;
1787 yylval.sval.length = namelen;
1788
1789 if (*tokstart == '$')
1790 {
1791 write_dollar_variable (yylval.sval);
1792 return VARIABLE;
1793 }
1794
1795 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1796 functions or symtabs. If this is not so, then ...
1797 Use token-type TYPENAME for symbols that happen to be defined
1798 currently as names of types; NAME for other symbols.
1799 The caller is not constrained to care about the distinction. */
1800 {
1801 char *tmp = copy_name (yylval.sval);
1802 struct symbol *sym;
1803 int is_a_field_of_this = 0;
1804 int hextype;
1805
1806 sym = lookup_symbol (tmp, expression_context_block,
1807 VAR_DOMAIN,
1808 current_language->la_language == language_cplus
1809 ? &is_a_field_of_this : (int *) NULL);
1810 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1811 no psymtabs (coff, xcoff, or some future change to blow away the
1812 psymtabs once once symbols are read). */
1813 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1814 {
1815 yylval.ssym.sym = sym;
1816 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1817 return BLOCKNAME;
1818 }
1819 else if (!sym)
1820 { /* See if it's a file name. */
1821 struct symtab *symtab;
1822
1823 symtab = lookup_symtab (tmp);
1824
1825 if (symtab)
1826 {
1827 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1828 return FILENAME;
1829 }
1830 }
1831
1832 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1833 {
1834 /* NOTE: carlton/2003-09-25: There used to be code here to
1835 handle nested types. It didn't work very well. See the
1836 comment before qualified_type for more info. */
1837 yylval.tsym.type = SYMBOL_TYPE (sym);
1838 return TYPENAME;
1839 }
1840 yylval.tsym.type
1841 = language_lookup_primitive_type_by_name (current_language,
1842 current_gdbarch, tmp);
1843 if (yylval.tsym.type != NULL)
1844 return TYPENAME;
1845
1846 /* Input names that aren't symbols but ARE valid hex numbers,
1847 when the input radix permits them, can be names or numbers
1848 depending on the parse. Note we support radixes > 16 here. */
1849 if (!sym &&
1850 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1851 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1852 {
1853 YYSTYPE newlval; /* Its value is ignored. */
1854 hextype = parse_number (tokstart, namelen, 0, &newlval);
1855 if (hextype == INT)
1856 {
1857 yylval.ssym.sym = sym;
1858 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1859 return NAME_OR_INT;
1860 }
1861 }
1862
1863 /* Any other kind of symbol */
1864 yylval.ssym.sym = sym;
1865 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1866 if (in_parse_field && *lexptr == '\0')
1867 saw_name_at_eof = 1;
1868 return NAME;
1869 }
1870 }
1871
1872 int
1873 c_parse (void)
1874 {
1875 last_was_structop = 0;
1876 saw_name_at_eof = 0;
1877 return yyparse ();
1878 }
1879
1880 void
1881 yyerror (msg)
1882 char *msg;
1883 {
1884 if (prev_lexptr)
1885 lexptr = prev_lexptr;
1886
1887 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1888 }
A mirror of the official binutils-gdb repository