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