?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2013-03-12 Sebastian Huber <sebastian.huber@embedded-brains.de>
[binutils-gdb.git] / gdb / c-exp.y
blobf6659d47fbec9423bc32207ac67508ef43d64f61
1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986-2013 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
18
19 /* Parse a C expression from text in a string,
20 and return the result as a struct expression pointer.
21 That structure contains arithmetic operations in reverse polish,
22 with constants represented by operations that are followed by special data.
23 See expression.h for the details of the format.
24 What is important here is that it can be built up sequentially
25 during the process of parsing; the lower levels of the tree always
26 come first in the result.
27
28 Note that malloc's and realloc's in this file are transformed to
29 xmalloc and xrealloc respectively by the same sed command in the
30 makefile that remaps any other malloc/realloc inserted by the parser
31 generator. Doing this with #defines and trying to control the interaction
32 with include files (<malloc.h> and <stdlib.h> for example) just became
33 too messy, particularly when such includes can be inserted at random
34 times by the parser generator. */
35
36 %{
37
38 #include "defs.h"
39 #include "gdb_string.h"
40 #include <ctype.h>
41 #include "expression.h"
42 #include "value.h"
43 #include "parser-defs.h"
44 #include "language.h"
45 #include "c-lang.h"
46 #include "bfd.h" /* Required by objfiles.h. */
47 #include "symfile.h" /* Required by objfiles.h. */
48 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
49 #include "charset.h"
50 #include "block.h"
51 #include "cp-support.h"
52 #include "dfp.h"
53 #include "gdb_assert.h"
54 #include "macroscope.h"
55 #include "objc-lang.h"
56 #include "typeprint.h"
57 #include "cp-abi.h"
58
59 #define parse_type builtin_type (parse_gdbarch)
60
61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
62 as well as gratuitiously global symbol names, so we can have multiple
63 yacc generated parsers in gdb. Note that these are only the variables
64 produced by yacc. If other parser generators (bison, byacc, etc) produce
65 additional global names that conflict at link time, then those parser
66 generators need to be fixed instead of adding those names to this list. */
67
68 #define yymaxdepth c_maxdepth
69 #define yyparse c_parse_internal
70 #define yylex c_lex
71 #define yyerror c_error
72 #define yylval c_lval
73 #define yychar c_char
74 #define yydebug c_debug
75 #define yypact c_pact
76 #define yyr1 c_r1
77 #define yyr2 c_r2
78 #define yydef c_def
79 #define yychk c_chk
80 #define yypgo c_pgo
81 #define yyact c_act
82 #define yyexca c_exca
83 #define yyerrflag c_errflag
84 #define yynerrs c_nerrs
85 #define yyps c_ps
86 #define yypv c_pv
87 #define yys c_s
88 #define yy_yys c_yys
89 #define yystate c_state
90 #define yytmp c_tmp
91 #define yyv c_v
92 #define yy_yyv c_yyv
93 #define yyval c_val
94 #define yylloc c_lloc
95 #define yyreds c_reds /* With YYDEBUG defined */
96 #define yytoks c_toks /* With YYDEBUG defined */
97 #define yyname c_name /* With YYDEBUG defined */
98 #define yyrule c_rule /* With YYDEBUG defined */
99 #define yylhs c_yylhs
100 #define yylen c_yylen
101 #define yydefred c_yydefred
102 #define yydgoto c_yydgoto
103 #define yysindex c_yysindex
104 #define yyrindex c_yyrindex
105 #define yygindex c_yygindex
106 #define yytable c_yytable
107 #define yycheck c_yycheck
108 #define yyss c_yyss
109 #define yysslim c_yysslim
110 #define yyssp c_yyssp
111 #define yystacksize c_yystacksize
112 #define yyvs c_yyvs
113 #define yyvsp c_yyvsp
114
115 #ifndef YYDEBUG
116 #define YYDEBUG 1 /* Default to yydebug support */
117 #endif
118
119 #define YYFPRINTF parser_fprintf
120
121 int yyparse (void);
122
123 static int yylex (void);
124
125 void yyerror (char *);
126
127 %}
128
129 /* Although the yacc "value" of an expression is not used,
130 since the result is stored in the structure being created,
131 other node types do have values. */
132
133 %union
134 {
135 LONGEST lval;
136 struct {
137 LONGEST val;
138 struct type *type;
139 } typed_val_int;
140 struct {
141 DOUBLEST dval;
142 struct type *type;
143 } typed_val_float;
144 struct {
145 gdb_byte val[16];
146 struct type *type;
147 } typed_val_decfloat;
148 struct symbol *sym;
149 struct type *tval;
150 struct stoken sval;
151 struct typed_stoken tsval;
152 struct ttype tsym;
153 struct symtoken ssym;
154 int voidval;
155 struct block *bval;
156 enum exp_opcode opcode;
157 struct internalvar *ivar;
158
159 struct stoken_vector svec;
160 VEC (type_ptr) *tvec;
161 int *ivec;
162
163 struct type_stack *type_stack;
164
165 struct objc_class_str class;
166 }
167
168 %{
169 /* YYSTYPE gets defined by %union */
170 static int parse_number (char *, int, int, YYSTYPE *);
171 static struct stoken operator_stoken (const char *);
172 static void check_parameter_typelist (VEC (type_ptr) *);
173 %}
174
175 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
176 %type <lval> rcurly
177 %type <tval> type typebase
178 %type <tvec> nonempty_typelist func_mod parameter_typelist
179 /* %type <bval> block */
180
181 /* Fancy type parsing. */
182 %type <tval> ptype
183 %type <lval> array_mod
184 %type <tval> conversion_type_id
185
186 %type <type_stack> ptr_operator_ts abs_decl direct_abs_decl
187
188 %token <typed_val_int> INT
189 %token <typed_val_float> FLOAT
190 %token <typed_val_decfloat> DECFLOAT
191
192 /* Both NAME and TYPENAME tokens represent symbols in the input,
193 and both convey their data as strings.
194 But a TYPENAME is a string that happens to be defined as a typedef
195 or builtin type name (such as int or char)
196 and a NAME is any other symbol.
197 Contexts where this distinction is not important can use the
198 nonterminal "name", which matches either NAME or TYPENAME. */
199
200 %token <tsval> STRING
201 %token <sval> NSSTRING /* ObjC Foundation "NSString" literal */
202 %token SELECTOR /* ObjC "@selector" pseudo-operator */
203 %token <tsval> CHAR
204 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
205 %token <ssym> UNKNOWN_CPP_NAME
206 %token <voidval> COMPLETE
207 %token <tsym> TYPENAME
208 %token <class> CLASSNAME /* ObjC Class name */
209 %type <sval> name
210 %type <svec> string_exp
211 %type <ssym> name_not_typename
212 %type <tsym> typename
213
214 /* This is like a '[' token, but is only generated when parsing
215 Objective C. This lets us reuse the same parser without
216 erroneously parsing ObjC-specific expressions in C. */
217 %token OBJC_LBRAC
218
219 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
220 but which would parse as a valid number in the current input radix.
221 E.g. "c" when input_radix==16. Depending on the parse, it will be
222 turned into a name or into a number. */
223
224 %token <ssym> NAME_OR_INT
225
226 %token OPERATOR
227 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
228 %token TEMPLATE
229 %token ERROR
230 %token NEW DELETE
231 %type <sval> operator
232 %token REINTERPRET_CAST DYNAMIC_CAST STATIC_CAST CONST_CAST
233 %token ENTRY
234 %token TYPEOF
235 %token DECLTYPE
236
237 /* Special type cases, put in to allow the parser to distinguish different
238 legal basetypes. */
239 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
240
241 %token <sval> VARIABLE
242
243 %token <opcode> ASSIGN_MODIFY
244
245 /* C++ */
246 %token TRUEKEYWORD
247 %token FALSEKEYWORD
248
249
250 %left ','
251 %left ABOVE_COMMA
252 %right '=' ASSIGN_MODIFY
253 %right '?'
254 %left OROR
255 %left ANDAND
256 %left '|'
257 %left '^'
258 %left '&'
259 %left EQUAL NOTEQUAL
260 %left '<' '>' LEQ GEQ
261 %left LSH RSH
262 %left '@'
263 %left '+' '-'
264 %left '*' '/' '%'
265 %right UNARY INCREMENT DECREMENT
266 %right ARROW ARROW_STAR '.' DOT_STAR '[' OBJC_LBRAC '('
267 %token <ssym> BLOCKNAME
268 %token <bval> FILENAME
269 %type <bval> block
270 %left COLONCOLON
271
272 %token DOTDOTDOT
273
274 \f
275 %%
276
277 start : exp1
278 | type_exp
279 ;
280
281 type_exp: type
282 { write_exp_elt_opcode(OP_TYPE);
283 write_exp_elt_type($1);
284 write_exp_elt_opcode(OP_TYPE);}
285 | TYPEOF '(' exp ')'
286 {
287 write_exp_elt_opcode (OP_TYPEOF);
288 }
289 | TYPEOF '(' type ')'
290 {
291 write_exp_elt_opcode (OP_TYPE);
292 write_exp_elt_type ($3);
293 write_exp_elt_opcode (OP_TYPE);
294 }
295 | DECLTYPE '(' exp ')'
296 {
297 write_exp_elt_opcode (OP_DECLTYPE);
298 }
299 ;
300
301 /* Expressions, including the comma operator. */
302 exp1 : exp
303 | exp1 ',' exp
304 { write_exp_elt_opcode (BINOP_COMMA); }
305 ;
306
307 /* Expressions, not including the comma operator. */
308 exp : '*' exp %prec UNARY
309 { write_exp_elt_opcode (UNOP_IND); }
310 ;
311
312 exp : '&' exp %prec UNARY
313 { write_exp_elt_opcode (UNOP_ADDR); }
314 ;
315
316 exp : '-' exp %prec UNARY
317 { write_exp_elt_opcode (UNOP_NEG); }
318 ;
319
320 exp : '+' exp %prec UNARY
321 { write_exp_elt_opcode (UNOP_PLUS); }
322 ;
323
324 exp : '!' exp %prec UNARY
325 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
326 ;
327
328 exp : '~' exp %prec UNARY
329 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
330 ;
331
332 exp : INCREMENT exp %prec UNARY
333 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
334 ;
335
336 exp : DECREMENT exp %prec UNARY
337 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
338 ;
339
340 exp : exp INCREMENT %prec UNARY
341 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
342 ;
343
344 exp : exp DECREMENT %prec UNARY
345 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
346 ;
347
348 exp : SIZEOF exp %prec UNARY
349 { write_exp_elt_opcode (UNOP_SIZEOF); }
350 ;
351
352 exp : exp ARROW name
353 { write_exp_elt_opcode (STRUCTOP_PTR);
354 write_exp_string ($3);
355 write_exp_elt_opcode (STRUCTOP_PTR); }
356 ;
357
358 exp : exp ARROW name COMPLETE
359 { mark_struct_expression ();
360 write_exp_elt_opcode (STRUCTOP_PTR);
361 write_exp_string ($3);
362 write_exp_elt_opcode (STRUCTOP_PTR); }
363 ;
364
365 exp : exp ARROW COMPLETE
366 { struct stoken s;
367 mark_struct_expression ();
368 write_exp_elt_opcode (STRUCTOP_PTR);
369 s.ptr = "";
370 s.length = 0;
371 write_exp_string (s);
372 write_exp_elt_opcode (STRUCTOP_PTR); }
373 ;
374
375 exp : exp ARROW qualified_name
376 { /* exp->type::name becomes exp->*(&type::name) */
377 /* Note: this doesn't work if name is a
378 static member! FIXME */
379 write_exp_elt_opcode (UNOP_ADDR);
380 write_exp_elt_opcode (STRUCTOP_MPTR); }
381 ;
382
383 exp : exp ARROW_STAR exp
384 { write_exp_elt_opcode (STRUCTOP_MPTR); }
385 ;
386
387 exp : exp '.' name
388 { write_exp_elt_opcode (STRUCTOP_STRUCT);
389 write_exp_string ($3);
390 write_exp_elt_opcode (STRUCTOP_STRUCT); }
391 ;
392
393 exp : exp '.' name COMPLETE
394 { mark_struct_expression ();
395 write_exp_elt_opcode (STRUCTOP_STRUCT);
396 write_exp_string ($3);
397 write_exp_elt_opcode (STRUCTOP_STRUCT); }
398 ;
399
400 exp : exp '.' COMPLETE
401 { struct stoken s;
402 mark_struct_expression ();
403 write_exp_elt_opcode (STRUCTOP_STRUCT);
404 s.ptr = "";
405 s.length = 0;
406 write_exp_string (s);
407 write_exp_elt_opcode (STRUCTOP_STRUCT); }
408 ;
409
410 exp : exp '.' qualified_name
411 { /* exp.type::name becomes exp.*(&type::name) */
412 /* Note: this doesn't work if name is a
413 static member! FIXME */
414 write_exp_elt_opcode (UNOP_ADDR);
415 write_exp_elt_opcode (STRUCTOP_MEMBER); }
416 ;
417
418 exp : exp DOT_STAR exp
419 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
420 ;
421
422 exp : exp '[' exp1 ']'
423 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
424 ;
425
426 exp : exp OBJC_LBRAC exp1 ']'
427 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
428 ;
429
430 /*
431 * The rules below parse ObjC message calls of the form:
432 * '[' target selector {':' argument}* ']'
433 */
434
435 exp : OBJC_LBRAC TYPENAME
436 {
437 CORE_ADDR class;
438
439 class = lookup_objc_class (parse_gdbarch,
440 copy_name ($2.stoken));
441 if (class == 0)
442 error (_("%s is not an ObjC Class"),
443 copy_name ($2.stoken));
444 write_exp_elt_opcode (OP_LONG);
445 write_exp_elt_type (parse_type->builtin_int);
446 write_exp_elt_longcst ((LONGEST) class);
447 write_exp_elt_opcode (OP_LONG);
448 start_msglist();
449 }
450 msglist ']'
451 { write_exp_elt_opcode (OP_OBJC_MSGCALL);
452 end_msglist();
453 write_exp_elt_opcode (OP_OBJC_MSGCALL);
454 }
455 ;
456
457 exp : OBJC_LBRAC CLASSNAME
458 {
459 write_exp_elt_opcode (OP_LONG);
460 write_exp_elt_type (parse_type->builtin_int);
461 write_exp_elt_longcst ((LONGEST) $2.class);
462 write_exp_elt_opcode (OP_LONG);
463 start_msglist();
464 }
465 msglist ']'
466 { write_exp_elt_opcode (OP_OBJC_MSGCALL);
467 end_msglist();
468 write_exp_elt_opcode (OP_OBJC_MSGCALL);
469 }
470 ;
471
472 exp : OBJC_LBRAC exp
473 { start_msglist(); }
474 msglist ']'
475 { write_exp_elt_opcode (OP_OBJC_MSGCALL);
476 end_msglist();
477 write_exp_elt_opcode (OP_OBJC_MSGCALL);
478 }
479 ;
480
481 msglist : name
482 { add_msglist(&$1, 0); }
483 | msgarglist
484 ;
485
486 msgarglist : msgarg
487 | msgarglist msgarg
488 ;
489
490 msgarg : name ':' exp
491 { add_msglist(&$1, 1); }
492 | ':' exp /* Unnamed arg. */
493 { add_msglist(0, 1); }
494 | ',' exp /* Variable number of args. */
495 { add_msglist(0, 0); }
496 ;
497
498 exp : exp '('
499 /* This is to save the value of arglist_len
500 being accumulated by an outer function call. */
501 { start_arglist (); }
502 arglist ')' %prec ARROW
503 { write_exp_elt_opcode (OP_FUNCALL);
504 write_exp_elt_longcst ((LONGEST) end_arglist ());
505 write_exp_elt_opcode (OP_FUNCALL); }
506 ;
507
508 exp : UNKNOWN_CPP_NAME '('
509 {
510 /* This could potentially be a an argument defined
511 lookup function (Koenig). */
512 write_exp_elt_opcode (OP_ADL_FUNC);
513 write_exp_elt_block (expression_context_block);
514 write_exp_elt_sym (NULL); /* Placeholder. */
515 write_exp_string ($1.stoken);
516 write_exp_elt_opcode (OP_ADL_FUNC);
517
518 /* This is to save the value of arglist_len
519 being accumulated by an outer function call. */
520
521 start_arglist ();
522 }
523 arglist ')' %prec ARROW
524 {
525 write_exp_elt_opcode (OP_FUNCALL);
526 write_exp_elt_longcst ((LONGEST) end_arglist ());
527 write_exp_elt_opcode (OP_FUNCALL);
528 }
529 ;
530
531 lcurly : '{'
532 { start_arglist (); }
533 ;
534
535 arglist :
536 ;
537
538 arglist : exp
539 { arglist_len = 1; }
540 ;
541
542 arglist : arglist ',' exp %prec ABOVE_COMMA
543 { arglist_len++; }
544 ;
545
546 exp : exp '(' parameter_typelist ')' const_or_volatile
547 { int i;
548 VEC (type_ptr) *type_list = $3;
549 struct type *type_elt;
550 LONGEST len = VEC_length (type_ptr, type_list);
551
552 write_exp_elt_opcode (TYPE_INSTANCE);
553 write_exp_elt_longcst (len);
554 for (i = 0;
555 VEC_iterate (type_ptr, type_list, i, type_elt);
556 ++i)
557 write_exp_elt_type (type_elt);
558 write_exp_elt_longcst(len);
559 write_exp_elt_opcode (TYPE_INSTANCE);
560 VEC_free (type_ptr, type_list);
561 }
562 ;
563
564 rcurly : '}'
565 { $$ = end_arglist () - 1; }
566 ;
567 exp : lcurly arglist rcurly %prec ARROW
568 { write_exp_elt_opcode (OP_ARRAY);
569 write_exp_elt_longcst ((LONGEST) 0);
570 write_exp_elt_longcst ((LONGEST) $3);
571 write_exp_elt_opcode (OP_ARRAY); }
572 ;
573
574 exp : lcurly type_exp rcurly exp %prec UNARY
575 { write_exp_elt_opcode (UNOP_MEMVAL_TYPE); }
576 ;
577
578 exp : '(' type_exp ')' exp %prec UNARY
579 { write_exp_elt_opcode (UNOP_CAST_TYPE); }
580 ;
581
582 exp : '(' exp1 ')'
583 { }
584 ;
585
586 /* Binary operators in order of decreasing precedence. */
587
588 exp : exp '@' exp
589 { write_exp_elt_opcode (BINOP_REPEAT); }
590 ;
591
592 exp : exp '*' exp
593 { write_exp_elt_opcode (BINOP_MUL); }
594 ;
595
596 exp : exp '/' exp
597 { write_exp_elt_opcode (BINOP_DIV); }
598 ;
599
600 exp : exp '%' exp
601 { write_exp_elt_opcode (BINOP_REM); }
602 ;
603
604 exp : exp '+' exp
605 { write_exp_elt_opcode (BINOP_ADD); }
606 ;
607
608 exp : exp '-' exp
609 { write_exp_elt_opcode (BINOP_SUB); }
610 ;
611
612 exp : exp LSH exp
613 { write_exp_elt_opcode (BINOP_LSH); }
614 ;
615
616 exp : exp RSH exp
617 { write_exp_elt_opcode (BINOP_RSH); }
618 ;
619
620 exp : exp EQUAL exp
621 { write_exp_elt_opcode (BINOP_EQUAL); }
622 ;
623
624 exp : exp NOTEQUAL exp
625 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
626 ;
627
628 exp : exp LEQ exp
629 { write_exp_elt_opcode (BINOP_LEQ); }
630 ;
631
632 exp : exp GEQ exp
633 { write_exp_elt_opcode (BINOP_GEQ); }
634 ;
635
636 exp : exp '<' exp
637 { write_exp_elt_opcode (BINOP_LESS); }
638 ;
639
640 exp : exp '>' exp
641 { write_exp_elt_opcode (BINOP_GTR); }
642 ;
643
644 exp : exp '&' exp
645 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
646 ;
647
648 exp : exp '^' exp
649 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
650 ;
651
652 exp : exp '|' exp
653 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
654 ;
655
656 exp : exp ANDAND exp
657 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
658 ;
659
660 exp : exp OROR exp
661 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
662 ;
663
664 exp : exp '?' exp ':' exp %prec '?'
665 { write_exp_elt_opcode (TERNOP_COND); }
666 ;
667
668 exp : exp '=' exp
669 { write_exp_elt_opcode (BINOP_ASSIGN); }
670 ;
671
672 exp : exp ASSIGN_MODIFY exp
673 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
674 write_exp_elt_opcode ($2);
675 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
676 ;
677
678 exp : INT
679 { write_exp_elt_opcode (OP_LONG);
680 write_exp_elt_type ($1.type);
681 write_exp_elt_longcst ((LONGEST)($1.val));
682 write_exp_elt_opcode (OP_LONG); }
683 ;
684
685 exp : CHAR
686 {
687 struct stoken_vector vec;
688 vec.len = 1;
689 vec.tokens = &$1;
690 write_exp_string_vector ($1.type, &vec);
691 }
692 ;
693
694 exp : NAME_OR_INT
695 { YYSTYPE val;
696 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
697 write_exp_elt_opcode (OP_LONG);
698 write_exp_elt_type (val.typed_val_int.type);
699 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
700 write_exp_elt_opcode (OP_LONG);
701 }
702 ;
703
704
705 exp : FLOAT
706 { write_exp_elt_opcode (OP_DOUBLE);
707 write_exp_elt_type ($1.type);
708 write_exp_elt_dblcst ($1.dval);
709 write_exp_elt_opcode (OP_DOUBLE); }
710 ;
711
712 exp : DECFLOAT
713 { write_exp_elt_opcode (OP_DECFLOAT);
714 write_exp_elt_type ($1.type);
715 write_exp_elt_decfloatcst ($1.val);
716 write_exp_elt_opcode (OP_DECFLOAT); }
717 ;
718
719 exp : variable
720 ;
721
722 exp : VARIABLE
723 {
724 write_dollar_variable ($1);
725 }
726 ;
727
728 exp : SELECTOR '(' name ')'
729 {
730 write_exp_elt_opcode (OP_OBJC_SELECTOR);
731 write_exp_string ($3);
732 write_exp_elt_opcode (OP_OBJC_SELECTOR); }
733 ;
734
735 exp : SIZEOF '(' type ')' %prec UNARY
736 { write_exp_elt_opcode (OP_LONG);
737 write_exp_elt_type (lookup_signed_typename
738 (parse_language, parse_gdbarch,
739 "int"));
740 CHECK_TYPEDEF ($3);
741 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
742 write_exp_elt_opcode (OP_LONG); }
743 ;
744
745 exp : REINTERPRET_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
746 { write_exp_elt_opcode (UNOP_REINTERPRET_CAST); }
747 ;
748
749 exp : STATIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
750 { write_exp_elt_opcode (UNOP_CAST_TYPE); }
751 ;
752
753 exp : DYNAMIC_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
754 { write_exp_elt_opcode (UNOP_DYNAMIC_CAST); }
755 ;
756
757 exp : CONST_CAST '<' type_exp '>' '(' exp ')' %prec UNARY
758 { /* We could do more error checking here, but
759 it doesn't seem worthwhile. */
760 write_exp_elt_opcode (UNOP_CAST_TYPE); }
761 ;
762
763 string_exp:
764 STRING
765 {
766 /* We copy the string here, and not in the
767 lexer, to guarantee that we do not leak a
768 string. Note that we follow the
769 NUL-termination convention of the
770 lexer. */
771 struct typed_stoken *vec = XNEW (struct typed_stoken);
772 $$.len = 1;
773 $$.tokens = vec;
774
775 vec->type = $1.type;
776 vec->length = $1.length;
777 vec->ptr = malloc ($1.length + 1);
778 memcpy (vec->ptr, $1.ptr, $1.length + 1);
779 }
780
781 | string_exp STRING
782 {
783 /* Note that we NUL-terminate here, but just
784 for convenience. */
785 char *p;
786 ++$$.len;
787 $$.tokens = realloc ($$.tokens,
788 $$.len * sizeof (struct typed_stoken));
789
790 p = malloc ($2.length + 1);
791 memcpy (p, $2.ptr, $2.length + 1);
792
793 $$.tokens[$$.len - 1].type = $2.type;
794 $$.tokens[$$.len - 1].length = $2.length;
795 $$.tokens[$$.len - 1].ptr = p;
796 }
797 ;
798
799 exp : string_exp
800 {
801 int i;
802 enum c_string_type type = C_STRING;
803
804 for (i = 0; i < $1.len; ++i)
805 {
806 switch ($1.tokens[i].type)
807 {
808 case C_STRING:
809 break;
810 case C_WIDE_STRING:
811 case C_STRING_16:
812 case C_STRING_32:
813 if (type != C_STRING
814 && type != $1.tokens[i].type)
815 error (_("Undefined string concatenation."));
816 type = $1.tokens[i].type;
817 break;
818 default:
819 /* internal error */
820 internal_error (__FILE__, __LINE__,
821 "unrecognized type in string concatenation");
822 }
823 }
824
825 write_exp_string_vector (type, &$1);
826 for (i = 0; i < $1.len; ++i)
827 free ($1.tokens[i].ptr);
828 free ($1.tokens);
829 }
830 ;
831
832 exp : NSSTRING /* ObjC NextStep NSString constant
833 * of the form '@' '"' string '"'.
834 */
835 { write_exp_elt_opcode (OP_OBJC_NSSTRING);
836 write_exp_string ($1);
837 write_exp_elt_opcode (OP_OBJC_NSSTRING); }
838 ;
839
840 /* C++. */
841 exp : TRUEKEYWORD
842 { write_exp_elt_opcode (OP_LONG);
843 write_exp_elt_type (parse_type->builtin_bool);
844 write_exp_elt_longcst ((LONGEST) 1);
845 write_exp_elt_opcode (OP_LONG); }
846 ;
847
848 exp : FALSEKEYWORD
849 { write_exp_elt_opcode (OP_LONG);
850 write_exp_elt_type (parse_type->builtin_bool);
851 write_exp_elt_longcst ((LONGEST) 0);
852 write_exp_elt_opcode (OP_LONG); }
853 ;
854
855 /* end of C++. */
856
857 block : BLOCKNAME
858 {
859 if ($1.sym)
860 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
861 else
862 error (_("No file or function \"%s\"."),
863 copy_name ($1.stoken));
864 }
865 | FILENAME
866 {
867 $$ = $1;
868 }
869 ;
870
871 block : block COLONCOLON name
872 { struct symbol *tem
873 = lookup_symbol (copy_name ($3), $1,
874 VAR_DOMAIN, NULL);
875 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
876 error (_("No function \"%s\" in specified context."),
877 copy_name ($3));
878 $$ = SYMBOL_BLOCK_VALUE (tem); }
879 ;
880
881 variable: name_not_typename ENTRY
882 { struct symbol *sym = $1.sym;
883
884 if (sym == NULL || !SYMBOL_IS_ARGUMENT (sym)
885 || !symbol_read_needs_frame (sym))
886 error (_("@entry can be used only for function "
887 "parameters, not for \"%s\""),
888 copy_name ($1.stoken));
889
890 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
891 write_exp_elt_sym (sym);
892 write_exp_elt_opcode (OP_VAR_ENTRY_VALUE);
893 }
894 ;
895
896 variable: block COLONCOLON name
897 { struct symbol *sym;
898 sym = lookup_symbol (copy_name ($3), $1,
899 VAR_DOMAIN, NULL);
900 if (sym == 0)
901 error (_("No symbol \"%s\" in specified context."),
902 copy_name ($3));
903 if (symbol_read_needs_frame (sym))
904 {
905 if (innermost_block == 0
906 || contained_in (block_found,
907 innermost_block))
908 innermost_block = block_found;
909 }
910
911 write_exp_elt_opcode (OP_VAR_VALUE);
912 /* block_found is set by lookup_symbol. */
913 write_exp_elt_block (block_found);
914 write_exp_elt_sym (sym);
915 write_exp_elt_opcode (OP_VAR_VALUE); }
916 ;
917
918 qualified_name: TYPENAME COLONCOLON name
919 {
920 struct type *type = $1.type;
921 CHECK_TYPEDEF (type);
922 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
923 && TYPE_CODE (type) != TYPE_CODE_UNION
924 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
925 error (_("`%s' is not defined as an aggregate type."),
926 TYPE_SAFE_NAME (type));
927
928 write_exp_elt_opcode (OP_SCOPE);
929 write_exp_elt_type (type);
930 write_exp_string ($3);
931 write_exp_elt_opcode (OP_SCOPE);
932 }
933 | TYPENAME COLONCOLON '~' name
934 {
935 struct type *type = $1.type;
936 struct stoken tmp_token;
937 CHECK_TYPEDEF (type);
938 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
939 && TYPE_CODE (type) != TYPE_CODE_UNION
940 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
941 error (_("`%s' is not defined as an aggregate type."),
942 TYPE_SAFE_NAME (type));
943
944 tmp_token.ptr = (char*) alloca ($4.length + 2);
945 tmp_token.length = $4.length + 1;
946 tmp_token.ptr[0] = '~';
947 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
948 tmp_token.ptr[tmp_token.length] = 0;
949
950 /* Check for valid destructor name. */
951 destructor_name_p (tmp_token.ptr, $1.type);
952 write_exp_elt_opcode (OP_SCOPE);
953 write_exp_elt_type (type);
954 write_exp_string (tmp_token);
955 write_exp_elt_opcode (OP_SCOPE);
956 }
957 | TYPENAME COLONCOLON name COLONCOLON name
958 {
959 char *copy = copy_name ($3);
960 error (_("No type \"%s\" within class "
961 "or namespace \"%s\"."),
962 copy, TYPE_SAFE_NAME ($1.type));
963 }
964 ;
965
966 variable: qualified_name
967 | COLONCOLON name_not_typename
968 {
969 char *name = copy_name ($2.stoken);
970 struct symbol *sym;
971 struct minimal_symbol *msymbol;
972
973 sym =
974 lookup_symbol (name, (const struct block *) NULL,
975 VAR_DOMAIN, NULL);
976 if (sym)
977 {
978 write_exp_elt_opcode (OP_VAR_VALUE);
979 write_exp_elt_block (NULL);
980 write_exp_elt_sym (sym);
981 write_exp_elt_opcode (OP_VAR_VALUE);
982 break;
983 }
984
985 msymbol = lookup_minimal_symbol (name, NULL, NULL);
986 if (msymbol != NULL)
987 write_exp_msymbol (msymbol);
988 else if (!have_full_symbols () && !have_partial_symbols ())
989 error (_("No symbol table is loaded. Use the \"file\" command."));
990 else
991 error (_("No symbol \"%s\" in current context."), name);
992 }
993 ;
994
995 variable: name_not_typename
996 { struct symbol *sym = $1.sym;
997
998 if (sym)
999 {
1000 if (symbol_read_needs_frame (sym))
1001 {
1002 if (innermost_block == 0
1003 || contained_in (block_found,
1004 innermost_block))
1005 innermost_block = block_found;
1006 }
1007
1008 write_exp_elt_opcode (OP_VAR_VALUE);
1009 /* We want to use the selected frame, not
1010 another more inner frame which happens to
1011 be in the same block. */
1012 write_exp_elt_block (NULL);
1013 write_exp_elt_sym (sym);
1014 write_exp_elt_opcode (OP_VAR_VALUE);
1015 }
1016 else if ($1.is_a_field_of_this)
1017 {
1018 /* C++: it hangs off of `this'. Must
1019 not inadvertently convert from a method call
1020 to data ref. */
1021 if (innermost_block == 0
1022 || contained_in (block_found,
1023 innermost_block))
1024 innermost_block = block_found;
1025 write_exp_elt_opcode (OP_THIS);
1026 write_exp_elt_opcode (OP_THIS);
1027 write_exp_elt_opcode (STRUCTOP_PTR);
1028 write_exp_string ($1.stoken);
1029 write_exp_elt_opcode (STRUCTOP_PTR);
1030 }
1031 else
1032 {
1033 struct minimal_symbol *msymbol;
1034 char *arg = copy_name ($1.stoken);
1035
1036 msymbol =
1037 lookup_minimal_symbol (arg, NULL, NULL);
1038 if (msymbol != NULL)
1039 write_exp_msymbol (msymbol);
1040 else if (!have_full_symbols () && !have_partial_symbols ())
1041 error (_("No symbol table is loaded. Use the \"file\" command."));
1042 else
1043 error (_("No symbol \"%s\" in current context."),
1044 copy_name ($1.stoken));
1045 }
1046 }
1047 ;
1048
1049 space_identifier : '@' NAME
1050 { insert_type_address_space (copy_name ($2.stoken)); }
1051 ;
1052
1053 const_or_volatile: const_or_volatile_noopt
1054 |
1055 ;
1056
1057 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
1058 ;
1059
1060 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
1061 | const_or_volatile_noopt
1062 ;
1063
1064 const_or_volatile_or_space_identifier:
1065 const_or_volatile_or_space_identifier_noopt
1066 |
1067 ;
1068
1069 ptr_operator:
1070 ptr_operator '*'
1071 { insert_type (tp_pointer); }
1072 const_or_volatile_or_space_identifier
1073 | '*'
1074 { insert_type (tp_pointer); }
1075 const_or_volatile_or_space_identifier
1076 | '&'
1077 { insert_type (tp_reference); }
1078 | '&' ptr_operator
1079 { insert_type (tp_reference); }
1080 ;
1081
1082 ptr_operator_ts: ptr_operator
1083 {
1084 $$ = get_type_stack ();
1085 /* This cleanup is eventually run by
1086 c_parse. */
1087 make_cleanup (type_stack_cleanup, $$);
1088 }
1089 ;
1090
1091 abs_decl: ptr_operator_ts direct_abs_decl
1092 { $$ = append_type_stack ($2, $1); }
1093 | ptr_operator_ts
1094 | direct_abs_decl
1095 ;
1096
1097 direct_abs_decl: '(' abs_decl ')'
1098 { $$ = $2; }
1099 | direct_abs_decl array_mod
1100 {
1101 push_type_stack ($1);
1102 push_type_int ($2);
1103 push_type (tp_array);
1104 $$ = get_type_stack ();
1105 }
1106 | array_mod
1107 {
1108 push_type_int ($1);
1109 push_type (tp_array);
1110 $$ = get_type_stack ();
1111 }
1112
1113 | direct_abs_decl func_mod
1114 {
1115 push_type_stack ($1);
1116 push_typelist ($2);
1117 $$ = get_type_stack ();
1118 }
1119 | func_mod
1120 {
1121 push_typelist ($1);
1122 $$ = get_type_stack ();
1123 }
1124 ;
1125
1126 array_mod: '[' ']'
1127 { $$ = -1; }
1128 | OBJC_LBRAC ']'
1129 { $$ = -1; }
1130 | '[' INT ']'
1131 { $$ = $2.val; }
1132 | OBJC_LBRAC INT ']'
1133 { $$ = $2.val; }
1134 ;
1135
1136 func_mod: '(' ')'
1137 { $$ = NULL; }
1138 | '(' parameter_typelist ')'
1139 { $$ = $2; }
1140 ;
1141
1142 /* We used to try to recognize pointer to member types here, but
1143 that didn't work (shift/reduce conflicts meant that these rules never
1144 got executed). The problem is that
1145 int (foo::bar::baz::bizzle)
1146 is a function type but
1147 int (foo::bar::baz::bizzle::*)
1148 is a pointer to member type. Stroustrup loses again! */
1149
1150 type : ptype
1151 ;
1152
1153 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
1154 : TYPENAME
1155 { $$ = $1.type; }
1156 | INT_KEYWORD
1157 { $$ = lookup_signed_typename (parse_language,
1158 parse_gdbarch,
1159 "int"); }
1160 | LONG
1161 { $$ = lookup_signed_typename (parse_language,
1162 parse_gdbarch,
1163 "long"); }
1164 | SHORT
1165 { $$ = lookup_signed_typename (parse_language,
1166 parse_gdbarch,
1167 "short"); }
1168 | LONG INT_KEYWORD
1169 { $$ = lookup_signed_typename (parse_language,
1170 parse_gdbarch,
1171 "long"); }
1172 | LONG SIGNED_KEYWORD INT_KEYWORD
1173 { $$ = lookup_signed_typename (parse_language,
1174 parse_gdbarch,
1175 "long"); }
1176 | LONG SIGNED_KEYWORD
1177 { $$ = lookup_signed_typename (parse_language,
1178 parse_gdbarch,
1179 "long"); }
1180 | SIGNED_KEYWORD LONG INT_KEYWORD
1181 { $$ = lookup_signed_typename (parse_language,
1182 parse_gdbarch,
1183 "long"); }
1184 | UNSIGNED LONG INT_KEYWORD
1185 { $$ = lookup_unsigned_typename (parse_language,
1186 parse_gdbarch,
1187 "long"); }
1188 | LONG UNSIGNED INT_KEYWORD
1189 { $$ = lookup_unsigned_typename (parse_language,
1190 parse_gdbarch,
1191 "long"); }
1192 | LONG UNSIGNED
1193 { $$ = lookup_unsigned_typename (parse_language,
1194 parse_gdbarch,
1195 "long"); }
1196 | LONG LONG
1197 { $$ = lookup_signed_typename (parse_language,
1198 parse_gdbarch,
1199 "long long"); }
1200 | LONG LONG INT_KEYWORD
1201 { $$ = lookup_signed_typename (parse_language,
1202 parse_gdbarch,
1203 "long long"); }
1204 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
1205 { $$ = lookup_signed_typename (parse_language,
1206 parse_gdbarch,
1207 "long long"); }
1208 | LONG LONG SIGNED_KEYWORD
1209 { $$ = lookup_signed_typename (parse_language,
1210 parse_gdbarch,
1211 "long long"); }
1212 | SIGNED_KEYWORD LONG LONG
1213 { $$ = lookup_signed_typename (parse_language,
1214 parse_gdbarch,
1215 "long long"); }
1216 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
1217 { $$ = lookup_signed_typename (parse_language,
1218 parse_gdbarch,
1219 "long long"); }
1220 | UNSIGNED LONG LONG
1221 { $$ = lookup_unsigned_typename (parse_language,
1222 parse_gdbarch,
1223 "long long"); }
1224 | UNSIGNED LONG LONG INT_KEYWORD
1225 { $$ = lookup_unsigned_typename (parse_language,
1226 parse_gdbarch,
1227 "long long"); }
1228 | LONG LONG UNSIGNED
1229 { $$ = lookup_unsigned_typename (parse_language,
1230 parse_gdbarch,
1231 "long long"); }
1232 | LONG LONG UNSIGNED INT_KEYWORD
1233 { $$ = lookup_unsigned_typename (parse_language,
1234 parse_gdbarch,
1235 "long long"); }
1236 | SHORT INT_KEYWORD
1237 { $$ = lookup_signed_typename (parse_language,
1238 parse_gdbarch,
1239 "short"); }
1240 | SHORT SIGNED_KEYWORD INT_KEYWORD
1241 { $$ = lookup_signed_typename (parse_language,
1242 parse_gdbarch,
1243 "short"); }
1244 | SHORT SIGNED_KEYWORD
1245 { $$ = lookup_signed_typename (parse_language,
1246 parse_gdbarch,
1247 "short"); }
1248 | UNSIGNED SHORT INT_KEYWORD
1249 { $$ = lookup_unsigned_typename (parse_language,
1250 parse_gdbarch,
1251 "short"); }
1252 | SHORT UNSIGNED
1253 { $$ = lookup_unsigned_typename (parse_language,
1254 parse_gdbarch,
1255 "short"); }
1256 | SHORT UNSIGNED INT_KEYWORD
1257 { $$ = lookup_unsigned_typename (parse_language,
1258 parse_gdbarch,
1259 "short"); }
1260 | DOUBLE_KEYWORD
1261 { $$ = lookup_typename (parse_language, parse_gdbarch,
1262 "double", (struct block *) NULL,
1263 0); }
1264 | LONG DOUBLE_KEYWORD
1265 { $$ = lookup_typename (parse_language, parse_gdbarch,
1266 "long double",
1267 (struct block *) NULL, 0); }
1268 | STRUCT name
1269 { $$ = lookup_struct (copy_name ($2),
1270 expression_context_block); }
1271 | STRUCT COMPLETE
1272 {
1273 mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
1274 $$ = NULL;
1275 }
1276 | STRUCT name COMPLETE
1277 {
1278 mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
1279 $2.length);
1280 $$ = NULL;
1281 }
1282 | CLASS name
1283 { $$ = lookup_struct (copy_name ($2),
1284 expression_context_block); }
1285 | CLASS COMPLETE
1286 {
1287 mark_completion_tag (TYPE_CODE_CLASS, "", 0);
1288 $$ = NULL;
1289 }
1290 | CLASS name COMPLETE
1291 {
1292 mark_completion_tag (TYPE_CODE_CLASS, $2.ptr,
1293 $2.length);
1294 $$ = NULL;
1295 }
1296 | UNION name
1297 { $$ = lookup_union (copy_name ($2),
1298 expression_context_block); }
1299 | UNION COMPLETE
1300 {
1301 mark_completion_tag (TYPE_CODE_UNION, "", 0);
1302 $$ = NULL;
1303 }
1304 | UNION name COMPLETE
1305 {
1306 mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
1307 $2.length);
1308 $$ = NULL;
1309 }
1310 | ENUM name
1311 { $$ = lookup_enum (copy_name ($2),
1312 expression_context_block); }
1313 | ENUM COMPLETE
1314 {
1315 mark_completion_tag (TYPE_CODE_ENUM, "", 0);
1316 $$ = NULL;
1317 }
1318 | ENUM name COMPLETE
1319 {
1320 mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
1321 $2.length);
1322 $$ = NULL;
1323 }
1324 | UNSIGNED typename
1325 { $$ = lookup_unsigned_typename (parse_language,
1326 parse_gdbarch,
1327 TYPE_NAME($2.type)); }
1328 | UNSIGNED
1329 { $$ = lookup_unsigned_typename (parse_language,
1330 parse_gdbarch,
1331 "int"); }
1332 | SIGNED_KEYWORD typename
1333 { $$ = lookup_signed_typename (parse_language,
1334 parse_gdbarch,
1335 TYPE_NAME($2.type)); }
1336 | SIGNED_KEYWORD
1337 { $$ = lookup_signed_typename (parse_language,
1338 parse_gdbarch,
1339 "int"); }
1340 /* It appears that this rule for templates is never
1341 reduced; template recognition happens by lookahead
1342 in the token processing code in yylex. */
1343 | TEMPLATE name '<' type '>'
1344 { $$ = lookup_template_type(copy_name($2), $4,
1345 expression_context_block);
1346 }
1347 | const_or_volatile_or_space_identifier_noopt typebase
1348 { $$ = follow_types ($2); }
1349 | typebase const_or_volatile_or_space_identifier_noopt
1350 { $$ = follow_types ($1); }
1351 ;
1352
1353 typename: TYPENAME
1354 | INT_KEYWORD
1355 {
1356 $$.stoken.ptr = "int";
1357 $$.stoken.length = 3;
1358 $$.type = lookup_signed_typename (parse_language,
1359 parse_gdbarch,
1360 "int");
1361 }
1362 | LONG
1363 {
1364 $$.stoken.ptr = "long";
1365 $$.stoken.length = 4;
1366 $$.type = lookup_signed_typename (parse_language,
1367 parse_gdbarch,
1368 "long");
1369 }
1370 | SHORT
1371 {
1372 $$.stoken.ptr = "short";
1373 $$.stoken.length = 5;
1374 $$.type = lookup_signed_typename (parse_language,
1375 parse_gdbarch,
1376 "short");
1377 }
1378 ;
1379
1380 parameter_typelist:
1381 nonempty_typelist
1382 { check_parameter_typelist ($1); }
1383 | nonempty_typelist ',' DOTDOTDOT
1384 {
1385 VEC_safe_push (type_ptr, $1, NULL);
1386 check_parameter_typelist ($1);
1387 $$ = $1;
1388 }
1389 ;
1390
1391 nonempty_typelist
1392 : type
1393 {
1394 VEC (type_ptr) *typelist = NULL;
1395 VEC_safe_push (type_ptr, typelist, $1);
1396 $$ = typelist;
1397 }
1398 | nonempty_typelist ',' type
1399 {
1400 VEC_safe_push (type_ptr, $1, $3);
1401 $$ = $1;
1402 }
1403 ;
1404
1405 ptype : typebase
1406 | ptype abs_decl
1407 {
1408 push_type_stack ($2);
1409 $$ = follow_types ($1);
1410 }
1411 ;
1412
1413 conversion_type_id: typebase conversion_declarator
1414 { $$ = follow_types ($1); }
1415 ;
1416
1417 conversion_declarator: /* Nothing. */
1418 | ptr_operator conversion_declarator
1419 ;
1420
1421 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1422 | VOLATILE_KEYWORD CONST_KEYWORD
1423 ;
1424
1425 const_or_volatile_noopt: const_and_volatile
1426 { insert_type (tp_const);
1427 insert_type (tp_volatile);
1428 }
1429 | CONST_KEYWORD
1430 { insert_type (tp_const); }
1431 | VOLATILE_KEYWORD
1432 { insert_type (tp_volatile); }
1433 ;
1434
1435 operator: OPERATOR NEW
1436 { $$ = operator_stoken (" new"); }
1437 | OPERATOR DELETE
1438 { $$ = operator_stoken (" delete"); }
1439 | OPERATOR NEW '[' ']'
1440 { $$ = operator_stoken (" new[]"); }
1441 | OPERATOR DELETE '[' ']'
1442 { $$ = operator_stoken (" delete[]"); }
1443 | OPERATOR NEW OBJC_LBRAC ']'
1444 { $$ = operator_stoken (" new[]"); }
1445 | OPERATOR DELETE OBJC_LBRAC ']'
1446 { $$ = operator_stoken (" delete[]"); }
1447 | OPERATOR '+'
1448 { $$ = operator_stoken ("+"); }
1449 | OPERATOR '-'
1450 { $$ = operator_stoken ("-"); }
1451 | OPERATOR '*'
1452 { $$ = operator_stoken ("*"); }
1453 | OPERATOR '/'
1454 { $$ = operator_stoken ("/"); }
1455 | OPERATOR '%'
1456 { $$ = operator_stoken ("%"); }
1457 | OPERATOR '^'
1458 { $$ = operator_stoken ("^"); }
1459 | OPERATOR '&'
1460 { $$ = operator_stoken ("&"); }
1461 | OPERATOR '|'
1462 { $$ = operator_stoken ("|"); }
1463 | OPERATOR '~'
1464 { $$ = operator_stoken ("~"); }
1465 | OPERATOR '!'
1466 { $$ = operator_stoken ("!"); }
1467 | OPERATOR '='
1468 { $$ = operator_stoken ("="); }
1469 | OPERATOR '<'
1470 { $$ = operator_stoken ("<"); }
1471 | OPERATOR '>'
1472 { $$ = operator_stoken (">"); }
1473 | OPERATOR ASSIGN_MODIFY
1474 { const char *op = "unknown";
1475 switch ($2)
1476 {
1477 case BINOP_RSH:
1478 op = ">>=";
1479 break;
1480 case BINOP_LSH:
1481 op = "<<=";
1482 break;
1483 case BINOP_ADD:
1484 op = "+=";
1485 break;
1486 case BINOP_SUB:
1487 op = "-=";
1488 break;
1489 case BINOP_MUL:
1490 op = "*=";
1491 break;
1492 case BINOP_DIV:
1493 op = "/=";
1494 break;
1495 case BINOP_REM:
1496 op = "%=";
1497 break;
1498 case BINOP_BITWISE_IOR:
1499 op = "|=";
1500 break;
1501 case BINOP_BITWISE_AND:
1502 op = "&=";
1503 break;
1504 case BINOP_BITWISE_XOR:
1505 op = "^=";
1506 break;
1507 default:
1508 break;
1509 }
1510
1511 $$ = operator_stoken (op);
1512 }
1513 | OPERATOR LSH
1514 { $$ = operator_stoken ("<<"); }
1515 | OPERATOR RSH
1516 { $$ = operator_stoken (">>"); }
1517 | OPERATOR EQUAL
1518 { $$ = operator_stoken ("=="); }
1519 | OPERATOR NOTEQUAL
1520 { $$ = operator_stoken ("!="); }
1521 | OPERATOR LEQ
1522 { $$ = operator_stoken ("<="); }
1523 | OPERATOR GEQ
1524 { $$ = operator_stoken (">="); }
1525 | OPERATOR ANDAND
1526 { $$ = operator_stoken ("&&"); }
1527 | OPERATOR OROR
1528 { $$ = operator_stoken ("||"); }
1529 | OPERATOR INCREMENT
1530 { $$ = operator_stoken ("++"); }
1531 | OPERATOR DECREMENT
1532 { $$ = operator_stoken ("--"); }
1533 | OPERATOR ','
1534 { $$ = operator_stoken (","); }
1535 | OPERATOR ARROW_STAR
1536 { $$ = operator_stoken ("->*"); }
1537 | OPERATOR ARROW
1538 { $$ = operator_stoken ("->"); }
1539 | OPERATOR '(' ')'
1540 { $$ = operator_stoken ("()"); }
1541 | OPERATOR '[' ']'
1542 { $$ = operator_stoken ("[]"); }
1543 | OPERATOR OBJC_LBRAC ']'
1544 { $$ = operator_stoken ("[]"); }
1545 | OPERATOR conversion_type_id
1546 { char *name;
1547 long length;
1548 struct ui_file *buf = mem_fileopen ();
1549
1550 c_print_type ($2, NULL, buf, -1, 0,
1551 &type_print_raw_options);
1552 name = ui_file_xstrdup (buf, &length);
1553 ui_file_delete (buf);
1554 $$ = operator_stoken (name);
1555 free (name);
1556 }
1557 ;
1558
1559
1560
1561 name : NAME { $$ = $1.stoken; }
1562 | BLOCKNAME { $$ = $1.stoken; }
1563 | TYPENAME { $$ = $1.stoken; }
1564 | NAME_OR_INT { $$ = $1.stoken; }
1565 | UNKNOWN_CPP_NAME { $$ = $1.stoken; }
1566 | operator { $$ = $1; }
1567 ;
1568
1569 name_not_typename : NAME
1570 | BLOCKNAME
1571 /* These would be useful if name_not_typename was useful, but it is just
1572 a fake for "variable", so these cause reduce/reduce conflicts because
1573 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1574 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1575 context where only a name could occur, this might be useful.
1576 | NAME_OR_INT
1577 */
1578 | operator
1579 {
1580 struct field_of_this_result is_a_field_of_this;
1581
1582 $$.stoken = $1;
1583 $$.sym = lookup_symbol ($1.ptr,
1584 expression_context_block,
1585 VAR_DOMAIN,
1586 &is_a_field_of_this);
1587 $$.is_a_field_of_this
1588 = is_a_field_of_this.type != NULL;
1589 }
1590 | UNKNOWN_CPP_NAME
1591 ;
1592
1593 %%
1594
1595 /* Returns a stoken of the operator name given by OP (which does not
1596 include the string "operator"). */
1597 static struct stoken
1598 operator_stoken (const char *op)
1599 {
1600 static const char *operator_string = "operator";
1601 struct stoken st = { NULL, 0 };
1602 st.length = strlen (operator_string) + strlen (op);
1603 st.ptr = malloc (st.length + 1);
1604 strcpy (st.ptr, operator_string);
1605 strcat (st.ptr, op);
1606
1607 /* The toplevel (c_parse) will free the memory allocated here. */
1608 make_cleanup (free, st.ptr);
1609 return st;
1610 };
1611
1612 /* Validate a parameter typelist. */
1613
1614 static void
1615 check_parameter_typelist (VEC (type_ptr) *params)
1616 {
1617 struct type *type;
1618 int ix;
1619
1620 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1621 {
1622 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1623 {
1624 if (ix == 0)
1625 {
1626 if (VEC_length (type_ptr, params) == 1)
1627 {
1628 /* Ok. */
1629 break;
1630 }
1631 VEC_free (type_ptr, params);
1632 error (_("parameter types following 'void'"));
1633 }
1634 else
1635 {
1636 VEC_free (type_ptr, params);
1637 error (_("'void' invalid as parameter type"));
1638 }
1639 }
1640 }
1641 }
1642
1643 /* Take care of parsing a number (anything that starts with a digit).
1644 Set yylval and return the token type; update lexptr.
1645 LEN is the number of characters in it. */
1646
1647 /*** Needs some error checking for the float case ***/
1648
1649 static int
1650 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1651 {
1652 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1653 here, and we do kind of silly things like cast to unsigned. */
1654 LONGEST n = 0;
1655 LONGEST prevn = 0;
1656 ULONGEST un;
1657
1658 int i = 0;
1659 int c;
1660 int base = input_radix;
1661 int unsigned_p = 0;
1662
1663 /* Number of "L" suffixes encountered. */
1664 int long_p = 0;
1665
1666 /* We have found a "L" or "U" suffix. */
1667 int found_suffix = 0;
1668
1669 ULONGEST high_bit;
1670 struct type *signed_type;
1671 struct type *unsigned_type;
1672
1673 if (parsed_float)
1674 {
1675 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1676 point. Return DECFLOAT. */
1677
1678 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1679 {
1680 p[len - 2] = '\0';
1681 putithere->typed_val_decfloat.type
1682 = parse_type->builtin_decfloat;
1683 decimal_from_string (putithere->typed_val_decfloat.val, 4,
1684 gdbarch_byte_order (parse_gdbarch), p);
1685 p[len - 2] = 'd';
1686 return DECFLOAT;
1687 }
1688
1689 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1690 {
1691 p[len - 2] = '\0';
1692 putithere->typed_val_decfloat.type
1693 = parse_type->builtin_decdouble;
1694 decimal_from_string (putithere->typed_val_decfloat.val, 8,
1695 gdbarch_byte_order (parse_gdbarch), p);
1696 p[len - 2] = 'd';
1697 return DECFLOAT;
1698 }
1699
1700 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1701 {
1702 p[len - 2] = '\0';
1703 putithere->typed_val_decfloat.type
1704 = parse_type->builtin_declong;
1705 decimal_from_string (putithere->typed_val_decfloat.val, 16,
1706 gdbarch_byte_order (parse_gdbarch), p);
1707 p[len - 2] = 'd';
1708 return DECFLOAT;
1709 }
1710
1711 if (! parse_c_float (parse_gdbarch, p, len,
1712 &putithere->typed_val_float.dval,
1713 &putithere->typed_val_float.type))
1714 return ERROR;
1715 return FLOAT;
1716 }
1717
1718 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1719 if (p[0] == '0')
1720 switch (p[1])
1721 {
1722 case 'x':
1723 case 'X':
1724 if (len >= 3)
1725 {
1726 p += 2;
1727 base = 16;
1728 len -= 2;
1729 }
1730 break;
1731
1732 case 'b':
1733 case 'B':
1734 if (len >= 3)
1735 {
1736 p += 2;
1737 base = 2;
1738 len -= 2;
1739 }
1740 break;
1741
1742 case 't':
1743 case 'T':
1744 case 'd':
1745 case 'D':
1746 if (len >= 3)
1747 {
1748 p += 2;
1749 base = 10;
1750 len -= 2;
1751 }
1752 break;
1753
1754 default:
1755 base = 8;
1756 break;
1757 }
1758
1759 while (len-- > 0)
1760 {
1761 c = *p++;
1762 if (c >= 'A' && c <= 'Z')
1763 c += 'a' - 'A';
1764 if (c != 'l' && c != 'u')
1765 n *= base;
1766 if (c >= '0' && c <= '9')
1767 {
1768 if (found_suffix)
1769 return ERROR;
1770 n += i = c - '0';
1771 }
1772 else
1773 {
1774 if (base > 10 && c >= 'a' && c <= 'f')
1775 {
1776 if (found_suffix)
1777 return ERROR;
1778 n += i = c - 'a' + 10;
1779 }
1780 else if (c == 'l')
1781 {
1782 ++long_p;
1783 found_suffix = 1;
1784 }
1785 else if (c == 'u')
1786 {
1787 unsigned_p = 1;
1788 found_suffix = 1;
1789 }
1790 else
1791 return ERROR; /* Char not a digit */
1792 }
1793 if (i >= base)
1794 return ERROR; /* Invalid digit in this base */
1795
1796 /* Portably test for overflow (only works for nonzero values, so make
1797 a second check for zero). FIXME: Can't we just make n and prevn
1798 unsigned and avoid this? */
1799 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1800 unsigned_p = 1; /* Try something unsigned */
1801
1802 /* Portably test for unsigned overflow.
1803 FIXME: This check is wrong; for example it doesn't find overflow
1804 on 0x123456789 when LONGEST is 32 bits. */
1805 if (c != 'l' && c != 'u' && n != 0)
1806 {
1807 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1808 error (_("Numeric constant too large."));
1809 }
1810 prevn = n;
1811 }
1812
1813 /* An integer constant is an int, a long, or a long long. An L
1814 suffix forces it to be long; an LL suffix forces it to be long
1815 long. If not forced to a larger size, it gets the first type of
1816 the above that it fits in. To figure out whether it fits, we
1817 shift it right and see whether anything remains. Note that we
1818 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1819 operation, because many compilers will warn about such a shift
1820 (which always produces a zero result). Sometimes gdbarch_int_bit
1821 or gdbarch_long_bit will be that big, sometimes not. To deal with
1822 the case where it is we just always shift the value more than
1823 once, with fewer bits each time. */
1824
1825 un = (ULONGEST)n >> 2;
1826 if (long_p == 0
1827 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1828 {
1829 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1830
1831 /* A large decimal (not hex or octal) constant (between INT_MAX
1832 and UINT_MAX) is a long or unsigned long, according to ANSI,
1833 never an unsigned int, but this code treats it as unsigned
1834 int. This probably should be fixed. GCC gives a warning on
1835 such constants. */
1836
1837 unsigned_type = parse_type->builtin_unsigned_int;
1838 signed_type = parse_type->builtin_int;
1839 }
1840 else if (long_p <= 1
1841 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1842 {
1843 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1844 unsigned_type = parse_type->builtin_unsigned_long;
1845 signed_type = parse_type->builtin_long;
1846 }
1847 else
1848 {
1849 int shift;
1850 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1851 < gdbarch_long_long_bit (parse_gdbarch))
1852 /* A long long does not fit in a LONGEST. */
1853 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1854 else
1855 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1856 high_bit = (ULONGEST) 1 << shift;
1857 unsigned_type = parse_type->builtin_unsigned_long_long;
1858 signed_type = parse_type->builtin_long_long;
1859 }
1860
1861 putithere->typed_val_int.val = n;
1862
1863 /* If the high bit of the worked out type is set then this number
1864 has to be unsigned. */
1865
1866 if (unsigned_p || (n & high_bit))
1867 {
1868 putithere->typed_val_int.type = unsigned_type;
1869 }
1870 else
1871 {
1872 putithere->typed_val_int.type = signed_type;
1873 }
1874
1875 return INT;
1876 }
1877
1878 /* Temporary obstack used for holding strings. */
1879 static struct obstack tempbuf;
1880 static int tempbuf_init;
1881
1882 /* Parse a C escape sequence. The initial backslash of the sequence
1883 is at (*PTR)[-1]. *PTR will be updated to point to just after the
1884 last character of the sequence. If OUTPUT is not NULL, the
1885 translated form of the escape sequence will be written there. If
1886 OUTPUT is NULL, no output is written and the call will only affect
1887 *PTR. If an escape sequence is expressed in target bytes, then the
1888 entire sequence will simply be copied to OUTPUT. Return 1 if any
1889 character was emitted, 0 otherwise. */
1890
1891 int
1892 c_parse_escape (char **ptr, struct obstack *output)
1893 {
1894 char *tokptr = *ptr;
1895 int result = 1;
1896
1897 /* Some escape sequences undergo character set conversion. Those we
1898 translate here. */
1899 switch (*tokptr)
1900 {
1901 /* Hex escapes do not undergo character set conversion, so keep
1902 the escape sequence for later. */
1903 case 'x':
1904 if (output)
1905 obstack_grow_str (output, "\\x");
1906 ++tokptr;
1907 if (!isxdigit (*tokptr))
1908 error (_("\\x escape without a following hex digit"));
1909 while (isxdigit (*tokptr))
1910 {
1911 if (output)
1912 obstack_1grow (output, *tokptr);
1913 ++tokptr;
1914 }
1915 break;
1916
1917 /* Octal escapes do not undergo character set conversion, so
1918 keep the escape sequence for later. */
1919 case '0':
1920 case '1':
1921 case '2':
1922 case '3':
1923 case '4':
1924 case '5':
1925 case '6':
1926 case '7':
1927 {
1928 int i;
1929 if (output)
1930 obstack_grow_str (output, "\\");
1931 for (i = 0;
1932 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1933 ++i)
1934 {
1935 if (output)
1936 obstack_1grow (output, *tokptr);
1937 ++tokptr;
1938 }
1939 }
1940 break;
1941
1942 /* We handle UCNs later. We could handle them here, but that
1943 would mean a spurious error in the case where the UCN could
1944 be converted to the target charset but not the host
1945 charset. */
1946 case 'u':
1947 case 'U':
1948 {
1949 char c = *tokptr;
1950 int i, len = c == 'U' ? 8 : 4;
1951 if (output)
1952 {
1953 obstack_1grow (output, '\\');
1954 obstack_1grow (output, *tokptr);
1955 }
1956 ++tokptr;
1957 if (!isxdigit (*tokptr))
1958 error (_("\\%c escape without a following hex digit"), c);
1959 for (i = 0; i < len && isxdigit (*tokptr); ++i)
1960 {
1961 if (output)
1962 obstack_1grow (output, *tokptr);
1963 ++tokptr;
1964 }
1965 }
1966 break;
1967
1968 /* We must pass backslash through so that it does not
1969 cause quoting during the second expansion. */
1970 case '\\':
1971 if (output)
1972 obstack_grow_str (output, "\\\\");
1973 ++tokptr;
1974 break;
1975
1976 /* Escapes which undergo conversion. */
1977 case 'a':
1978 if (output)
1979 obstack_1grow (output, '\a');
1980 ++tokptr;
1981 break;
1982 case 'b':
1983 if (output)
1984 obstack_1grow (output, '\b');
1985 ++tokptr;
1986 break;
1987 case 'f':
1988 if (output)
1989 obstack_1grow (output, '\f');
1990 ++tokptr;
1991 break;
1992 case 'n':
1993 if (output)
1994 obstack_1grow (output, '\n');
1995 ++tokptr;
1996 break;
1997 case 'r':
1998 if (output)
1999 obstack_1grow (output, '\r');
2000 ++tokptr;
2001 break;
2002 case 't':
2003 if (output)
2004 obstack_1grow (output, '\t');
2005 ++tokptr;
2006 break;
2007 case 'v':
2008 if (output)
2009 obstack_1grow (output, '\v');
2010 ++tokptr;
2011 break;
2012
2013 /* GCC extension. */
2014 case 'e':
2015 if (output)
2016 obstack_1grow (output, HOST_ESCAPE_CHAR);
2017 ++tokptr;
2018 break;
2019
2020 /* Backslash-newline expands to nothing at all. */
2021 case '\n':
2022 ++tokptr;
2023 result = 0;
2024 break;
2025
2026 /* A few escapes just expand to the character itself. */
2027 case '\'':
2028 case '\"':
2029 case '?':
2030 /* GCC extensions. */
2031 case '(':
2032 case '{':
2033 case '[':
2034 case '%':
2035 /* Unrecognized escapes turn into the character itself. */
2036 default:
2037 if (output)
2038 obstack_1grow (output, *tokptr);
2039 ++tokptr;
2040 break;
2041 }
2042 *ptr = tokptr;
2043 return result;
2044 }
2045
2046 /* Parse a string or character literal from TOKPTR. The string or
2047 character may be wide or unicode. *OUTPTR is set to just after the
2048 end of the literal in the input string. The resulting token is
2049 stored in VALUE. This returns a token value, either STRING or
2050 CHAR, depending on what was parsed. *HOST_CHARS is set to the
2051 number of host characters in the literal. */
2052 static int
2053 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
2054 int *host_chars)
2055 {
2056 int quote;
2057 enum c_string_type type;
2058 int is_objc = 0;
2059
2060 /* Build the gdb internal form of the input string in tempbuf. Note
2061 that the buffer is null byte terminated *only* for the
2062 convenience of debugging gdb itself and printing the buffer
2063 contents when the buffer contains no embedded nulls. Gdb does
2064 not depend upon the buffer being null byte terminated, it uses
2065 the length string instead. This allows gdb to handle C strings
2066 (as well as strings in other languages) with embedded null
2067 bytes */
2068
2069 if (!tempbuf_init)
2070 tempbuf_init = 1;
2071 else
2072 obstack_free (&tempbuf, NULL);
2073 obstack_init (&tempbuf);
2074
2075 /* Record the string type. */
2076 if (*tokptr == 'L')
2077 {
2078 type = C_WIDE_STRING;
2079 ++tokptr;
2080 }
2081 else if (*tokptr == 'u')
2082 {
2083 type = C_STRING_16;
2084 ++tokptr;
2085 }
2086 else if (*tokptr == 'U')
2087 {
2088 type = C_STRING_32;
2089 ++tokptr;
2090 }
2091 else if (*tokptr == '@')
2092 {
2093 /* An Objective C string. */
2094 is_objc = 1;
2095 type = C_STRING;
2096 ++tokptr;
2097 }
2098 else
2099 type = C_STRING;
2100
2101 /* Skip the quote. */
2102 quote = *tokptr;
2103 if (quote == '\'')
2104 type |= C_CHAR;
2105 ++tokptr;
2106
2107 *host_chars = 0;
2108
2109 while (*tokptr)
2110 {
2111 char c = *tokptr;
2112 if (c == '\\')
2113 {
2114 ++tokptr;
2115 *host_chars += c_parse_escape (&tokptr, &tempbuf);
2116 }
2117 else if (c == quote)
2118 break;
2119 else
2120 {
2121 obstack_1grow (&tempbuf, c);
2122 ++tokptr;
2123 /* FIXME: this does the wrong thing with multi-byte host
2124 characters. We could use mbrlen here, but that would
2125 make "set host-charset" a bit less useful. */
2126 ++*host_chars;
2127 }
2128 }
2129
2130 if (*tokptr != quote)
2131 {
2132 if (quote == '"')
2133 error (_("Unterminated string in expression."));
2134 else
2135 error (_("Unmatched single quote."));
2136 }
2137 ++tokptr;
2138
2139 value->type = type;
2140 value->ptr = obstack_base (&tempbuf);
2141 value->length = obstack_object_size (&tempbuf);
2142
2143 *outptr = tokptr;
2144
2145 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2146 }
2147
2148 /* This is used to associate some attributes with a token. */
2149
2150 enum token_flags
2151 {
2152 /* If this bit is set, the token is C++-only. */
2153
2154 FLAG_CXX = 1,
2155
2156 /* If this bit is set, the token is conditional: if there is a
2157 symbol of the same name, then the token is a symbol; otherwise,
2158 the token is a keyword. */
2159
2160 FLAG_SHADOW = 2
2161 };
2162
2163 struct token
2164 {
2165 char *operator;
2166 int token;
2167 enum exp_opcode opcode;
2168 enum token_flags flags;
2169 };
2170
2171 static const struct token tokentab3[] =
2172 {
2173 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2174 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2175 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2176 {"...", DOTDOTDOT, BINOP_END, 0}
2177 };
2178
2179 static const struct token tokentab2[] =
2180 {
2181 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2182 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2183 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2184 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2185 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2186 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2187 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2188 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2189 {"++", INCREMENT, BINOP_END, 0},
2190 {"--", DECREMENT, BINOP_END, 0},
2191 {"->", ARROW, BINOP_END, 0},
2192 {"&&", ANDAND, BINOP_END, 0},
2193 {"||", OROR, BINOP_END, 0},
2194 /* "::" is *not* only C++: gdb overrides its meaning in several
2195 different ways, e.g., 'filename'::func, function::variable. */
2196 {"::", COLONCOLON, BINOP_END, 0},
2197 {"<<", LSH, BINOP_END, 0},
2198 {">>", RSH, BINOP_END, 0},
2199 {"==", EQUAL, BINOP_END, 0},
2200 {"!=", NOTEQUAL, BINOP_END, 0},
2201 {"<=", LEQ, BINOP_END, 0},
2202 {">=", GEQ, BINOP_END, 0},
2203 {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2204 };
2205
2206 /* Identifier-like tokens. */
2207 static const struct token ident_tokens[] =
2208 {
2209 {"unsigned", UNSIGNED, OP_NULL, 0},
2210 {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2211 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2212 {"struct", STRUCT, OP_NULL, 0},
2213 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2214 {"sizeof", SIZEOF, OP_NULL, 0},
2215 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2216 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2217 {"class", CLASS, OP_NULL, FLAG_CXX},
2218 {"union", UNION, OP_NULL, 0},
2219 {"short", SHORT, OP_NULL, 0},
2220 {"const", CONST_KEYWORD, OP_NULL, 0},
2221 {"enum", ENUM, OP_NULL, 0},
2222 {"long", LONG, OP_NULL, 0},
2223 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2224 {"int", INT_KEYWORD, OP_NULL, 0},
2225 {"new", NEW, OP_NULL, FLAG_CXX},
2226 {"delete", DELETE, OP_NULL, FLAG_CXX},
2227 {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2228
2229 {"and", ANDAND, BINOP_END, FLAG_CXX},
2230 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2231 {"bitand", '&', OP_NULL, FLAG_CXX},
2232 {"bitor", '|', OP_NULL, FLAG_CXX},
2233 {"compl", '~', OP_NULL, FLAG_CXX},
2234 {"not", '!', OP_NULL, FLAG_CXX},
2235 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2236 {"or", OROR, BINOP_END, FLAG_CXX},
2237 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2238 {"xor", '^', OP_NULL, FLAG_CXX},
2239 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2240
2241 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2242 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2243 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2244 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2245
2246 {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2247 {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2248 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2249 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2250 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW }
2251 };
2252
2253 /* When we find that lexptr (the global var defined in parse.c) is
2254 pointing at a macro invocation, we expand the invocation, and call
2255 scan_macro_expansion to save the old lexptr here and point lexptr
2256 into the expanded text. When we reach the end of that, we call
2257 end_macro_expansion to pop back to the value we saved here. The
2258 macro expansion code promises to return only fully-expanded text,
2259 so we don't need to "push" more than one level.
2260
2261 This is disgusting, of course. It would be cleaner to do all macro
2262 expansion beforehand, and then hand that to lexptr. But we don't
2263 really know where the expression ends. Remember, in a command like
2264
2265 (gdb) break *ADDRESS if CONDITION
2266
2267 we evaluate ADDRESS in the scope of the current frame, but we
2268 evaluate CONDITION in the scope of the breakpoint's location. So
2269 it's simply wrong to try to macro-expand the whole thing at once. */
2270 static char *macro_original_text;
2271
2272 /* We save all intermediate macro expansions on this obstack for the
2273 duration of a single parse. The expansion text may sometimes have
2274 to live past the end of the expansion, due to yacc lookahead.
2275 Rather than try to be clever about saving the data for a single
2276 token, we simply keep it all and delete it after parsing has
2277 completed. */
2278 static struct obstack expansion_obstack;
2279
2280 static void
2281 scan_macro_expansion (char *expansion)
2282 {
2283 char *copy;
2284
2285 /* We'd better not be trying to push the stack twice. */
2286 gdb_assert (! macro_original_text);
2287
2288 /* Copy to the obstack, and then free the intermediate
2289 expansion. */
2290 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2291 xfree (expansion);
2292
2293 /* Save the old lexptr value, so we can return to it when we're done
2294 parsing the expanded text. */
2295 macro_original_text = lexptr;
2296 lexptr = copy;
2297 }
2298
2299
2300 static int
2301 scanning_macro_expansion (void)
2302 {
2303 return macro_original_text != 0;
2304 }
2305
2306
2307 static void
2308 finished_macro_expansion (void)
2309 {
2310 /* There'd better be something to pop back to. */
2311 gdb_assert (macro_original_text);
2312
2313 /* Pop back to the original text. */
2314 lexptr = macro_original_text;
2315 macro_original_text = 0;
2316 }
2317
2318
2319 static void
2320 scan_macro_cleanup (void *dummy)
2321 {
2322 if (macro_original_text)
2323 finished_macro_expansion ();
2324
2325 obstack_free (&expansion_obstack, NULL);
2326 }
2327
2328 /* Return true iff the token represents a C++ cast operator. */
2329
2330 static int
2331 is_cast_operator (const char *token, int len)
2332 {
2333 return (! strncmp (token, "dynamic_cast", len)
2334 || ! strncmp (token, "static_cast", len)
2335 || ! strncmp (token, "reinterpret_cast", len)
2336 || ! strncmp (token, "const_cast", len));
2337 }
2338
2339 /* The scope used for macro expansion. */
2340 static struct macro_scope *expression_macro_scope;
2341
2342 /* This is set if a NAME token appeared at the very end of the input
2343 string, with no whitespace separating the name from the EOF. This
2344 is used only when parsing to do field name completion. */
2345 static int saw_name_at_eof;
2346
2347 /* This is set if the previously-returned token was a structure
2348 operator -- either '.' or ARROW. This is used only when parsing to
2349 do field name completion. */
2350 static int last_was_structop;
2351
2352 /* Read one token, getting characters through lexptr. */
2353
2354 static int
2355 lex_one_token (void)
2356 {
2357 int c;
2358 int namelen;
2359 unsigned int i;
2360 char *tokstart;
2361 int saw_structop = last_was_structop;
2362 char *copy;
2363
2364 last_was_structop = 0;
2365
2366 retry:
2367
2368 /* Check if this is a macro invocation that we need to expand. */
2369 if (! scanning_macro_expansion ())
2370 {
2371 char *expanded = macro_expand_next (&lexptr,
2372 standard_macro_lookup,
2373 expression_macro_scope);
2374
2375 if (expanded)
2376 scan_macro_expansion (expanded);
2377 }
2378
2379 prev_lexptr = lexptr;
2380
2381 tokstart = lexptr;
2382 /* See if it is a special token of length 3. */
2383 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2384 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2385 {
2386 if ((tokentab3[i].flags & FLAG_CXX) != 0
2387 && parse_language->la_language != language_cplus)
2388 break;
2389
2390 lexptr += 3;
2391 yylval.opcode = tokentab3[i].opcode;
2392 return tokentab3[i].token;
2393 }
2394
2395 /* See if it is a special token of length 2. */
2396 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2397 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2398 {
2399 if ((tokentab2[i].flags & FLAG_CXX) != 0
2400 && parse_language->la_language != language_cplus)
2401 break;
2402
2403 lexptr += 2;
2404 yylval.opcode = tokentab2[i].opcode;
2405 if (parse_completion && tokentab2[i].token == ARROW)
2406 last_was_structop = 1;
2407 return tokentab2[i].token;
2408 }
2409
2410 switch (c = *tokstart)
2411 {
2412 case 0:
2413 /* If we were just scanning the result of a macro expansion,
2414 then we need to resume scanning the original text.
2415 If we're parsing for field name completion, and the previous
2416 token allows such completion, return a COMPLETE token.
2417 Otherwise, we were already scanning the original text, and
2418 we're really done. */
2419 if (scanning_macro_expansion ())
2420 {
2421 finished_macro_expansion ();
2422 goto retry;
2423 }
2424 else if (saw_name_at_eof)
2425 {
2426 saw_name_at_eof = 0;
2427 return COMPLETE;
2428 }
2429 else if (saw_structop)
2430 return COMPLETE;
2431 else
2432 return 0;
2433
2434 case ' ':
2435 case '\t':
2436 case '\n':
2437 lexptr++;
2438 goto retry;
2439
2440 case '[':
2441 case '(':
2442 paren_depth++;
2443 lexptr++;
2444 if (parse_language->la_language == language_objc && c == '[')
2445 return OBJC_LBRAC;
2446 return c;
2447
2448 case ']':
2449 case ')':
2450 if (paren_depth == 0)
2451 return 0;
2452 paren_depth--;
2453 lexptr++;
2454 return c;
2455
2456 case ',':
2457 if (comma_terminates
2458 && paren_depth == 0
2459 && ! scanning_macro_expansion ())
2460 return 0;
2461 lexptr++;
2462 return c;
2463
2464 case '.':
2465 /* Might be a floating point number. */
2466 if (lexptr[1] < '0' || lexptr[1] > '9')
2467 {
2468 if (parse_completion)
2469 last_was_structop = 1;
2470 goto symbol; /* Nope, must be a symbol. */
2471 }
2472 /* FALL THRU into number case. */
2473
2474 case '0':
2475 case '1':
2476 case '2':
2477 case '3':
2478 case '4':
2479 case '5':
2480 case '6':
2481 case '7':
2482 case '8':
2483 case '9':
2484 {
2485 /* It's a number. */
2486 int got_dot = 0, got_e = 0, toktype;
2487 char *p = tokstart;
2488 int hex = input_radix > 10;
2489
2490 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2491 {
2492 p += 2;
2493 hex = 1;
2494 }
2495 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2496 {
2497 p += 2;
2498 hex = 0;
2499 }
2500
2501 for (;; ++p)
2502 {
2503 /* This test includes !hex because 'e' is a valid hex digit
2504 and thus does not indicate a floating point number when
2505 the radix is hex. */
2506 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2507 got_dot = got_e = 1;
2508 /* This test does not include !hex, because a '.' always indicates
2509 a decimal floating point number regardless of the radix. */
2510 else if (!got_dot && *p == '.')
2511 got_dot = 1;
2512 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2513 && (*p == '-' || *p == '+'))
2514 /* This is the sign of the exponent, not the end of the
2515 number. */
2516 continue;
2517 /* We will take any letters or digits. parse_number will
2518 complain if past the radix, or if L or U are not final. */
2519 else if ((*p < '0' || *p > '9')
2520 && ((*p < 'a' || *p > 'z')
2521 && (*p < 'A' || *p > 'Z')))
2522 break;
2523 }
2524 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2525 if (toktype == ERROR)
2526 {
2527 char *err_copy = (char *) alloca (p - tokstart + 1);
2528
2529 memcpy (err_copy, tokstart, p - tokstart);
2530 err_copy[p - tokstart] = 0;
2531 error (_("Invalid number \"%s\"."), err_copy);
2532 }
2533 lexptr = p;
2534 return toktype;
2535 }
2536
2537 case '@':
2538 {
2539 char *p = &tokstart[1];
2540 size_t len = strlen ("entry");
2541
2542 if (parse_language->la_language == language_objc)
2543 {
2544 size_t len = strlen ("selector");
2545
2546 if (strncmp (p, "selector", len) == 0
2547 && (p[len] == '\0' || isspace (p[len])))
2548 {
2549 lexptr = p + len;
2550 return SELECTOR;
2551 }
2552 else if (*p == '"')
2553 goto parse_string;
2554 }
2555
2556 while (isspace (*p))
2557 p++;
2558 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2559 && p[len] != '_')
2560 {
2561 lexptr = &p[len];
2562 return ENTRY;
2563 }
2564 }
2565 /* FALLTHRU */
2566 case '+':
2567 case '-':
2568 case '*':
2569 case '/':
2570 case '%':
2571 case '|':
2572 case '&':
2573 case '^':
2574 case '~':
2575 case '!':
2576 case '<':
2577 case '>':
2578 case '?':
2579 case ':':
2580 case '=':
2581 case '{':
2582 case '}':
2583 symbol:
2584 lexptr++;
2585 return c;
2586
2587 case 'L':
2588 case 'u':
2589 case 'U':
2590 if (tokstart[1] != '"' && tokstart[1] != '\'')
2591 break;
2592 /* Fall through. */
2593 case '\'':
2594 case '"':
2595
2596 parse_string:
2597 {
2598 int host_len;
2599 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2600 &host_len);
2601 if (result == CHAR)
2602 {
2603 if (host_len == 0)
2604 error (_("Empty character constant."));
2605 else if (host_len > 2 && c == '\'')
2606 {
2607 ++tokstart;
2608 namelen = lexptr - tokstart - 1;
2609 goto tryname;
2610 }
2611 else if (host_len > 1)
2612 error (_("Invalid character constant."));
2613 }
2614 return result;
2615 }
2616 }
2617
2618 if (!(c == '_' || c == '$'
2619 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2620 /* We must have come across a bad character (e.g. ';'). */
2621 error (_("Invalid character '%c' in expression."), c);
2622
2623 /* It's a name. See how long it is. */
2624 namelen = 0;
2625 for (c = tokstart[namelen];
2626 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2627 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2628 {
2629 /* Template parameter lists are part of the name.
2630 FIXME: This mishandles `print $a<4&&$a>3'. */
2631
2632 if (c == '<')
2633 {
2634 if (! is_cast_operator (tokstart, namelen))
2635 {
2636 /* Scan ahead to get rest of the template specification. Note
2637 that we look ahead only when the '<' adjoins non-whitespace
2638 characters; for comparison expressions, e.g. "a < b > c",
2639 there must be spaces before the '<', etc. */
2640
2641 char * p = find_template_name_end (tokstart + namelen);
2642 if (p)
2643 namelen = p - tokstart;
2644 }
2645 break;
2646 }
2647 c = tokstart[++namelen];
2648 }
2649
2650 /* The token "if" terminates the expression and is NOT removed from
2651 the input stream. It doesn't count if it appears in the
2652 expansion of a macro. */
2653 if (namelen == 2
2654 && tokstart[0] == 'i'
2655 && tokstart[1] == 'f'
2656 && ! scanning_macro_expansion ())
2657 {
2658 return 0;
2659 }
2660
2661 /* For the same reason (breakpoint conditions), "thread N"
2662 terminates the expression. "thread" could be an identifier, but
2663 an identifier is never followed by a number without intervening
2664 punctuation. "task" is similar. Handle abbreviations of these,
2665 similarly to breakpoint.c:find_condition_and_thread. */
2666 if (namelen >= 1
2667 && (strncmp (tokstart, "thread", namelen) == 0
2668 || strncmp (tokstart, "task", namelen) == 0)
2669 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2670 && ! scanning_macro_expansion ())
2671 {
2672 char *p = tokstart + namelen + 1;
2673 while (*p == ' ' || *p == '\t')
2674 p++;
2675 if (*p >= '0' && *p <= '9')
2676 return 0;
2677 }
2678
2679 lexptr += namelen;
2680
2681 tryname:
2682
2683 yylval.sval.ptr = tokstart;
2684 yylval.sval.length = namelen;
2685
2686 /* Catch specific keywords. */
2687 copy = copy_name (yylval.sval);
2688 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2689 if (strcmp (copy, ident_tokens[i].operator) == 0)
2690 {
2691 if ((ident_tokens[i].flags & FLAG_CXX) != 0
2692 && parse_language->la_language != language_cplus)
2693 break;
2694
2695 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2696 {
2697 struct field_of_this_result is_a_field_of_this;
2698
2699 if (lookup_symbol (copy, expression_context_block,
2700 VAR_DOMAIN,
2701 (parse_language->la_language == language_cplus
2702 ? &is_a_field_of_this
2703 : NULL))
2704 != NULL)
2705 {
2706 /* The keyword is shadowed. */
2707 break;
2708 }
2709 }
2710
2711 /* It is ok to always set this, even though we don't always
2712 strictly need to. */
2713 yylval.opcode = ident_tokens[i].opcode;
2714 return ident_tokens[i].token;
2715 }
2716
2717 if (*tokstart == '$')
2718 return VARIABLE;
2719
2720 if (parse_completion && *lexptr == '\0')
2721 saw_name_at_eof = 1;
2722
2723 yylval.ssym.stoken = yylval.sval;
2724 yylval.ssym.sym = NULL;
2725 yylval.ssym.is_a_field_of_this = 0;
2726 return NAME;
2727 }
2728
2729 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
2730 typedef struct
2731 {
2732 int token;
2733 YYSTYPE value;
2734 } token_and_value;
2735
2736 DEF_VEC_O (token_and_value);
2737
2738 /* A FIFO of tokens that have been read but not yet returned to the
2739 parser. */
2740 static VEC (token_and_value) *token_fifo;
2741
2742 /* Non-zero if the lexer should return tokens from the FIFO. */
2743 static int popping;
2744
2745 /* Temporary storage for c_lex; this holds symbol names as they are
2746 built up. */
2747 static struct obstack name_obstack;
2748
2749 /* Classify a NAME token. The contents of the token are in `yylval'.
2750 Updates yylval and returns the new token type. BLOCK is the block
2751 in which lookups start; this can be NULL to mean the global
2752 scope. */
2753 static int
2754 classify_name (const struct block *block)
2755 {
2756 struct symbol *sym;
2757 char *copy;
2758 struct field_of_this_result is_a_field_of_this;
2759
2760 copy = copy_name (yylval.sval);
2761
2762 /* Initialize this in case we *don't* use it in this call; that way
2763 we can refer to it unconditionally below. */
2764 memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
2765
2766 sym = lookup_symbol (copy, block, VAR_DOMAIN,
2767 parse_language->la_name_of_this
2768 ? &is_a_field_of_this : NULL);
2769
2770 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2771 {
2772 yylval.ssym.sym = sym;
2773 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2774 return BLOCKNAME;
2775 }
2776 else if (!sym)
2777 {
2778 /* See if it's a file name. */
2779 struct symtab *symtab;
2780
2781 symtab = lookup_symtab (copy);
2782 if (symtab)
2783 {
2784 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2785 return FILENAME;
2786 }
2787
2788 /* If we found a field of 'this', we might have erroneously
2789 found a constructor where we wanted a type name. Handle this
2790 case by noticing that we found a constructor and then look up
2791 the type tag instead. */
2792 if (is_a_field_of_this.type != NULL
2793 && is_a_field_of_this.fn_field != NULL
2794 && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
2795 0))
2796 {
2797 struct field_of_this_result inner_is_a_field_of_this;
2798
2799 sym = lookup_symbol (copy, block, STRUCT_DOMAIN,
2800 &inner_is_a_field_of_this);
2801 if (sym != NULL)
2802 {
2803 yylval.tsym.type = SYMBOL_TYPE (sym);
2804 return TYPENAME;
2805 }
2806 }
2807 }
2808
2809 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2810 {
2811 yylval.tsym.type = SYMBOL_TYPE (sym);
2812 return TYPENAME;
2813 }
2814
2815 yylval.tsym.type
2816 = language_lookup_primitive_type_by_name (parse_language,
2817 parse_gdbarch, copy);
2818 if (yylval.tsym.type != NULL)
2819 return TYPENAME;
2820
2821 /* See if it's an ObjC classname. */
2822 if (parse_language->la_language == language_objc && !sym)
2823 {
2824 CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy);
2825 if (Class)
2826 {
2827 yylval.class.class = Class;
2828 sym = lookup_struct_typedef (copy, expression_context_block, 1);
2829 if (sym)
2830 yylval.class.type = SYMBOL_TYPE (sym);
2831 return CLASSNAME;
2832 }
2833 }
2834
2835 /* Input names that aren't symbols but ARE valid hex numbers, when
2836 the input radix permits them, can be names or numbers depending
2837 on the parse. Note we support radixes > 16 here. */
2838 if (!sym
2839 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2840 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2841 {
2842 YYSTYPE newlval; /* Its value is ignored. */
2843 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
2844 if (hextype == INT)
2845 {
2846 yylval.ssym.sym = sym;
2847 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2848 return NAME_OR_INT;
2849 }
2850 }
2851
2852 /* Any other kind of symbol */
2853 yylval.ssym.sym = sym;
2854 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2855
2856 if (sym == NULL
2857 && parse_language->la_language == language_cplus
2858 && is_a_field_of_this.type == NULL
2859 && !lookup_minimal_symbol (copy, NULL, NULL))
2860 return UNKNOWN_CPP_NAME;
2861
2862 return NAME;
2863 }
2864
2865 /* Like classify_name, but used by the inner loop of the lexer, when a
2866 name might have already been seen. CONTEXT is the context type, or
2867 NULL if this is the first component of a name. */
2868
2869 static int
2870 classify_inner_name (const struct block *block, struct type *context)
2871 {
2872 struct type *type;
2873 char *copy;
2874
2875 if (context == NULL)
2876 return classify_name (block);
2877
2878 type = check_typedef (context);
2879 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2880 && TYPE_CODE (type) != TYPE_CODE_UNION
2881 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2882 return ERROR;
2883
2884 copy = copy_name (yylval.ssym.stoken);
2885 yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block);
2886 if (yylval.ssym.sym == NULL)
2887 return ERROR;
2888
2889 switch (SYMBOL_CLASS (yylval.ssym.sym))
2890 {
2891 case LOC_BLOCK:
2892 case LOC_LABEL:
2893 return ERROR;
2894
2895 case LOC_TYPEDEF:
2896 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
2897 return TYPENAME;
2898
2899 default:
2900 return NAME;
2901 }
2902 internal_error (__FILE__, __LINE__, _("not reached"));
2903 }
2904
2905 /* The outer level of a two-level lexer. This calls the inner lexer
2906 to return tokens. It then either returns these tokens, or
2907 aggregates them into a larger token. This lets us work around a
2908 problem in our parsing approach, where the parser could not
2909 distinguish between qualified names and qualified types at the
2910 right point.
2911
2912 This approach is still not ideal, because it mishandles template
2913 types. See the comment in lex_one_token for an example. However,
2914 this is still an improvement over the earlier approach, and will
2915 suffice until we move to better parsing technology. */
2916 static int
2917 yylex (void)
2918 {
2919 token_and_value current;
2920 int first_was_coloncolon, last_was_coloncolon, first_iter;
2921 struct type *context_type = NULL;
2922
2923 if (popping && !VEC_empty (token_and_value, token_fifo))
2924 {
2925 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
2926 VEC_ordered_remove (token_and_value, token_fifo, 0);
2927 yylval = tv.value;
2928 return tv.token;
2929 }
2930 popping = 0;
2931
2932 current.token = lex_one_token ();
2933 if (current.token == NAME)
2934 current.token = classify_name (expression_context_block);
2935 if (parse_language->la_language != language_cplus
2936 || (current.token != TYPENAME && current.token != COLONCOLON))
2937 return current.token;
2938
2939 first_was_coloncolon = current.token == COLONCOLON;
2940 last_was_coloncolon = first_was_coloncolon;
2941 obstack_free (&name_obstack, obstack_base (&name_obstack));
2942 if (!last_was_coloncolon)
2943 {
2944 obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
2945 context_type = yylval.tsym.type;
2946 }
2947 current.value = yylval;
2948 first_iter = 1;
2949 while (1)
2950 {
2951 token_and_value next;
2952
2953 next.token = lex_one_token ();
2954 next.value = yylval;
2955
2956 if (next.token == NAME && last_was_coloncolon)
2957 {
2958 int classification;
2959
2960 classification = classify_inner_name (first_was_coloncolon
2961 ? NULL
2962 : expression_context_block,
2963 context_type);
2964 /* We keep going until we either run out of names, or until
2965 we have a qualified name which is not a type. */
2966 if (classification != TYPENAME && classification != NAME)
2967 {
2968 /* Push the final component and leave the loop. */
2969 VEC_safe_push (token_and_value, token_fifo, &next);
2970 break;
2971 }
2972
2973 /* Update the partial name we are constructing. */
2974 if (context_type != NULL)
2975 {
2976 /* We don't want to put a leading "::" into the name. */
2977 obstack_grow_str (&name_obstack, "::");
2978 }
2979 obstack_grow (&name_obstack, next.value.sval.ptr,
2980 next.value.sval.length);
2981
2982 yylval.sval.ptr = obstack_base (&name_obstack);
2983 yylval.sval.length = obstack_object_size (&name_obstack);
2984 current.value = yylval;
2985 current.token = classification;
2986
2987 last_was_coloncolon = 0;
2988
2989 if (classification == NAME)
2990 break;
2991
2992 context_type = yylval.tsym.type;
2993 }
2994 else if (next.token == COLONCOLON && !last_was_coloncolon)
2995 last_was_coloncolon = 1;
2996 else
2997 {
2998 /* We've reached the end of the name. */
2999 VEC_safe_push (token_and_value, token_fifo, &next);
3000 break;
3001 }
3002
3003 first_iter = 0;
3004 }
3005
3006 popping = 1;
3007
3008 /* If we ended with a "::", insert it too. */
3009 if (last_was_coloncolon)
3010 {
3011 token_and_value cc;
3012 memset (&cc, 0, sizeof (token_and_value));
3013 if (first_was_coloncolon && first_iter)
3014 {
3015 yylval = cc.value;
3016 return COLONCOLON;
3017 }
3018 cc.token = COLONCOLON;
3019 VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
3020 }
3021
3022 yylval = current.value;
3023 yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
3024 yylval.sval.ptr,
3025 yylval.sval.length);
3026 return current.token;
3027 }
3028
3029 int
3030 c_parse (void)
3031 {
3032 int result;
3033 struct cleanup *back_to = make_cleanup (free_current_contents,
3034 &expression_macro_scope);
3035
3036 /* Set up the scope for macro expansion. */
3037 expression_macro_scope = NULL;
3038
3039 if (expression_context_block)
3040 expression_macro_scope
3041 = sal_macro_scope (find_pc_line (expression_context_pc, 0));
3042 else
3043 expression_macro_scope = default_macro_scope ();
3044 if (! expression_macro_scope)
3045 expression_macro_scope = user_macro_scope ();
3046
3047 /* Initialize macro expansion code. */
3048 obstack_init (&expansion_obstack);
3049 gdb_assert (! macro_original_text);
3050 make_cleanup (scan_macro_cleanup, 0);
3051
3052 make_cleanup_restore_integer (&yydebug);
3053 yydebug = parser_debug;
3054
3055 /* Initialize some state used by the lexer. */
3056 last_was_structop = 0;
3057 saw_name_at_eof = 0;
3058
3059 VEC_free (token_and_value, token_fifo);
3060 popping = 0;
3061 obstack_init (&name_obstack);
3062 make_cleanup_obstack_free (&name_obstack);
3063
3064 result = yyparse ();
3065 do_cleanups (back_to);
3066 return result;
3067 }
3068
3069
3070 void
3071 yyerror (char *msg)
3072 {
3073 if (prev_lexptr)
3074 lexptr = prev_lexptr;
3075
3076 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
3077 }
The GNU Binutils are a collection of binary tools.