projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix gdb.base/stale-infcall.exp's copyright line.
[deliverable/binutils-gdb.git] / gdb / c-exp.y
1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989-2000, 2003-2004, 2006-2012 Free Software
3 Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* Parse a C expression from text in a string,
21 and return the result as a struct expression pointer.
22 That structure contains arithmetic operations in reverse polish,
23 with constants represented by operations that are followed by special data.
24 See expression.h for the details of the format.
25 What is important here is that it can be built up sequentially
26 during the process of parsing; the lower levels of the tree always
27 come first in the result.
28
29 Note that malloc's and realloc's in this file are transformed to
30 xmalloc and xrealloc respectively by the same sed command in the
31 makefile that remaps any other malloc/realloc inserted by the parser
32 generator. Doing this with #defines and trying to control the interaction
33 with include files (<malloc.h> and <stdlib.h> for example) just became
34 too messy, particularly when such includes can be inserted at random
35 times by the parser generator. */
36
37 %{
38
39 #include "defs.h"
40 #include "gdb_string.h"
41 #include <ctype.h>
42 #include "expression.h"
43 #include "value.h"
44 #include "parser-defs.h"
45 #include "language.h"
46 #include "c-lang.h"
47 #include "bfd.h" /* Required by objfiles.h. */
48 #include "symfile.h" /* Required by objfiles.h. */
49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
50 #include "charset.h"
51 #include "block.h"
52 #include "cp-support.h"
53 #include "dfp.h"
54 #include "gdb_assert.h"
55 #include "macroscope.h"
56 #include "objc-lang.h"
57 #include "typeprint.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, (int *) 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, (int *) 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_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_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_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, (int *) 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 | CLASS name
1272 { $$ = lookup_struct (copy_name ($2),
1273 expression_context_block); }
1274 | UNION name
1275 { $$ = lookup_union (copy_name ($2),
1276 expression_context_block); }
1277 | ENUM name
1278 { $$ = lookup_enum (copy_name ($2),
1279 expression_context_block); }
1280 | UNSIGNED typename
1281 { $$ = lookup_unsigned_typename (parse_language,
1282 parse_gdbarch,
1283 TYPE_NAME($2.type)); }
1284 | UNSIGNED
1285 { $$ = lookup_unsigned_typename (parse_language,
1286 parse_gdbarch,
1287 "int"); }
1288 | SIGNED_KEYWORD typename
1289 { $$ = lookup_signed_typename (parse_language,
1290 parse_gdbarch,
1291 TYPE_NAME($2.type)); }
1292 | SIGNED_KEYWORD
1293 { $$ = lookup_signed_typename (parse_language,
1294 parse_gdbarch,
1295 "int"); }
1296 /* It appears that this rule for templates is never
1297 reduced; template recognition happens by lookahead
1298 in the token processing code in yylex. */
1299 | TEMPLATE name '<' type '>'
1300 { $$ = lookup_template_type(copy_name($2), $4,
1301 expression_context_block);
1302 }
1303 | const_or_volatile_or_space_identifier_noopt typebase
1304 { $$ = follow_types ($2); }
1305 | typebase const_or_volatile_or_space_identifier_noopt
1306 { $$ = follow_types ($1); }
1307 ;
1308
1309 typename: TYPENAME
1310 | INT_KEYWORD
1311 {
1312 $$.stoken.ptr = "int";
1313 $$.stoken.length = 3;
1314 $$.type = lookup_signed_typename (parse_language,
1315 parse_gdbarch,
1316 "int");
1317 }
1318 | LONG
1319 {
1320 $$.stoken.ptr = "long";
1321 $$.stoken.length = 4;
1322 $$.type = lookup_signed_typename (parse_language,
1323 parse_gdbarch,
1324 "long");
1325 }
1326 | SHORT
1327 {
1328 $$.stoken.ptr = "short";
1329 $$.stoken.length = 5;
1330 $$.type = lookup_signed_typename (parse_language,
1331 parse_gdbarch,
1332 "short");
1333 }
1334 ;
1335
1336 parameter_typelist:
1337 nonempty_typelist
1338 { check_parameter_typelist ($1); }
1339 | nonempty_typelist ',' DOTDOTDOT
1340 {
1341 VEC_safe_push (type_ptr, $1, NULL);
1342 check_parameter_typelist ($1);
1343 $$ = $1;
1344 }
1345 ;
1346
1347 nonempty_typelist
1348 : type
1349 {
1350 VEC (type_ptr) *typelist = NULL;
1351 VEC_safe_push (type_ptr, typelist, $1);
1352 $$ = typelist;
1353 }
1354 | nonempty_typelist ',' type
1355 {
1356 VEC_safe_push (type_ptr, $1, $3);
1357 $$ = $1;
1358 }
1359 ;
1360
1361 ptype : typebase
1362 | ptype abs_decl
1363 {
1364 push_type_stack ($2);
1365 $$ = follow_types ($1);
1366 }
1367 ;
1368
1369 conversion_type_id: typebase conversion_declarator
1370 { $$ = follow_types ($1); }
1371 ;
1372
1373 conversion_declarator: /* Nothing. */
1374 | ptr_operator conversion_declarator
1375 ;
1376
1377 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1378 | VOLATILE_KEYWORD CONST_KEYWORD
1379 ;
1380
1381 const_or_volatile_noopt: const_and_volatile
1382 { insert_type (tp_const);
1383 insert_type (tp_volatile);
1384 }
1385 | CONST_KEYWORD
1386 { insert_type (tp_const); }
1387 | VOLATILE_KEYWORD
1388 { insert_type (tp_volatile); }
1389 ;
1390
1391 operator: OPERATOR NEW
1392 { $$ = operator_stoken (" new"); }
1393 | OPERATOR DELETE
1394 { $$ = operator_stoken (" delete"); }
1395 | OPERATOR NEW '[' ']'
1396 { $$ = operator_stoken (" new[]"); }
1397 | OPERATOR DELETE '[' ']'
1398 { $$ = operator_stoken (" delete[]"); }
1399 | OPERATOR NEW OBJC_LBRAC ']'
1400 { $$ = operator_stoken (" new[]"); }
1401 | OPERATOR DELETE OBJC_LBRAC ']'
1402 { $$ = operator_stoken (" delete[]"); }
1403 | OPERATOR '+'
1404 { $$ = operator_stoken ("+"); }
1405 | OPERATOR '-'
1406 { $$ = operator_stoken ("-"); }
1407 | OPERATOR '*'
1408 { $$ = operator_stoken ("*"); }
1409 | OPERATOR '/'
1410 { $$ = operator_stoken ("/"); }
1411 | OPERATOR '%'
1412 { $$ = operator_stoken ("%"); }
1413 | OPERATOR '^'
1414 { $$ = operator_stoken ("^"); }
1415 | OPERATOR '&'
1416 { $$ = operator_stoken ("&"); }
1417 | OPERATOR '|'
1418 { $$ = operator_stoken ("|"); }
1419 | OPERATOR '~'
1420 { $$ = operator_stoken ("~"); }
1421 | OPERATOR '!'
1422 { $$ = operator_stoken ("!"); }
1423 | OPERATOR '='
1424 { $$ = operator_stoken ("="); }
1425 | OPERATOR '<'
1426 { $$ = operator_stoken ("<"); }
1427 | OPERATOR '>'
1428 { $$ = operator_stoken (">"); }
1429 | OPERATOR ASSIGN_MODIFY
1430 { const char *op = "unknown";
1431 switch ($2)
1432 {
1433 case BINOP_RSH:
1434 op = ">>=";
1435 break;
1436 case BINOP_LSH:
1437 op = "<<=";
1438 break;
1439 case BINOP_ADD:
1440 op = "+=";
1441 break;
1442 case BINOP_SUB:
1443 op = "-=";
1444 break;
1445 case BINOP_MUL:
1446 op = "*=";
1447 break;
1448 case BINOP_DIV:
1449 op = "/=";
1450 break;
1451 case BINOP_REM:
1452 op = "%=";
1453 break;
1454 case BINOP_BITWISE_IOR:
1455 op = "|=";
1456 break;
1457 case BINOP_BITWISE_AND:
1458 op = "&=";
1459 break;
1460 case BINOP_BITWISE_XOR:
1461 op = "^=";
1462 break;
1463 default:
1464 break;
1465 }
1466
1467 $$ = operator_stoken (op);
1468 }
1469 | OPERATOR LSH
1470 { $$ = operator_stoken ("<<"); }
1471 | OPERATOR RSH
1472 { $$ = operator_stoken (">>"); }
1473 | OPERATOR EQUAL
1474 { $$ = operator_stoken ("=="); }
1475 | OPERATOR NOTEQUAL
1476 { $$ = operator_stoken ("!="); }
1477 | OPERATOR LEQ
1478 { $$ = operator_stoken ("<="); }
1479 | OPERATOR GEQ
1480 { $$ = operator_stoken (">="); }
1481 | OPERATOR ANDAND
1482 { $$ = operator_stoken ("&&"); }
1483 | OPERATOR OROR
1484 { $$ = operator_stoken ("||"); }
1485 | OPERATOR INCREMENT
1486 { $$ = operator_stoken ("++"); }
1487 | OPERATOR DECREMENT
1488 { $$ = operator_stoken ("--"); }
1489 | OPERATOR ','
1490 { $$ = operator_stoken (","); }
1491 | OPERATOR ARROW_STAR
1492 { $$ = operator_stoken ("->*"); }
1493 | OPERATOR ARROW
1494 { $$ = operator_stoken ("->"); }
1495 | OPERATOR '(' ')'
1496 { $$ = operator_stoken ("()"); }
1497 | OPERATOR '[' ']'
1498 { $$ = operator_stoken ("[]"); }
1499 | OPERATOR OBJC_LBRAC ']'
1500 { $$ = operator_stoken ("[]"); }
1501 | OPERATOR conversion_type_id
1502 { char *name;
1503 long length;
1504 struct ui_file *buf = mem_fileopen ();
1505
1506 c_print_type ($2, NULL, buf, -1, 0,
1507 &type_print_raw_options);
1508 name = ui_file_xstrdup (buf, &length);
1509 ui_file_delete (buf);
1510 $$ = operator_stoken (name);
1511 free (name);
1512 }
1513 ;
1514
1515
1516
1517 name : NAME { $$ = $1.stoken; }
1518 | BLOCKNAME { $$ = $1.stoken; }
1519 | TYPENAME { $$ = $1.stoken; }
1520 | NAME_OR_INT { $$ = $1.stoken; }
1521 | UNKNOWN_CPP_NAME { $$ = $1.stoken; }
1522 | operator { $$ = $1; }
1523 ;
1524
1525 name_not_typename : NAME
1526 | BLOCKNAME
1527 /* These would be useful if name_not_typename was useful, but it is just
1528 a fake for "variable", so these cause reduce/reduce conflicts because
1529 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1530 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1531 context where only a name could occur, this might be useful.
1532 | NAME_OR_INT
1533 */
1534 | operator
1535 {
1536 $$.stoken = $1;
1537 $$.sym = lookup_symbol ($1.ptr,
1538 expression_context_block,
1539 VAR_DOMAIN,
1540 &$$.is_a_field_of_this);
1541 }
1542 | UNKNOWN_CPP_NAME
1543 ;
1544
1545 %%
1546
1547 /* Returns a stoken of the operator name given by OP (which does not
1548 include the string "operator"). */
1549 static struct stoken
1550 operator_stoken (const char *op)
1551 {
1552 static const char *operator_string = "operator";
1553 struct stoken st = { NULL, 0 };
1554 st.length = strlen (operator_string) + strlen (op);
1555 st.ptr = malloc (st.length + 1);
1556 strcpy (st.ptr, operator_string);
1557 strcat (st.ptr, op);
1558
1559 /* The toplevel (c_parse) will free the memory allocated here. */
1560 make_cleanup (free, st.ptr);
1561 return st;
1562 };
1563
1564 /* Validate a parameter typelist. */
1565
1566 static void
1567 check_parameter_typelist (VEC (type_ptr) *params)
1568 {
1569 struct type *type;
1570 int ix;
1571
1572 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1573 {
1574 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1575 {
1576 if (ix == 0)
1577 {
1578 if (VEC_length (type_ptr, params) == 1)
1579 {
1580 /* Ok. */
1581 break;
1582 }
1583 VEC_free (type_ptr, params);
1584 error (_("parameter types following 'void'"));
1585 }
1586 else
1587 {
1588 VEC_free (type_ptr, params);
1589 error (_("'void' invalid as parameter type"));
1590 }
1591 }
1592 }
1593 }
1594
1595 /* Take care of parsing a number (anything that starts with a digit).
1596 Set yylval and return the token type; update lexptr.
1597 LEN is the number of characters in it. */
1598
1599 /*** Needs some error checking for the float case ***/
1600
1601 static int
1602 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1603 {
1604 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1605 here, and we do kind of silly things like cast to unsigned. */
1606 LONGEST n = 0;
1607 LONGEST prevn = 0;
1608 ULONGEST un;
1609
1610 int i = 0;
1611 int c;
1612 int base = input_radix;
1613 int unsigned_p = 0;
1614
1615 /* Number of "L" suffixes encountered. */
1616 int long_p = 0;
1617
1618 /* We have found a "L" or "U" suffix. */
1619 int found_suffix = 0;
1620
1621 ULONGEST high_bit;
1622 struct type *signed_type;
1623 struct type *unsigned_type;
1624
1625 if (parsed_float)
1626 {
1627 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1628 point. Return DECFLOAT. */
1629
1630 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1631 {
1632 p[len - 2] = '\0';
1633 putithere->typed_val_decfloat.type
1634 = parse_type->builtin_decfloat;
1635 decimal_from_string (putithere->typed_val_decfloat.val, 4,
1636 gdbarch_byte_order (parse_gdbarch), p);
1637 p[len - 2] = 'd';
1638 return DECFLOAT;
1639 }
1640
1641 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1642 {
1643 p[len - 2] = '\0';
1644 putithere->typed_val_decfloat.type
1645 = parse_type->builtin_decdouble;
1646 decimal_from_string (putithere->typed_val_decfloat.val, 8,
1647 gdbarch_byte_order (parse_gdbarch), p);
1648 p[len - 2] = 'd';
1649 return DECFLOAT;
1650 }
1651
1652 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1653 {
1654 p[len - 2] = '\0';
1655 putithere->typed_val_decfloat.type
1656 = parse_type->builtin_declong;
1657 decimal_from_string (putithere->typed_val_decfloat.val, 16,
1658 gdbarch_byte_order (parse_gdbarch), p);
1659 p[len - 2] = 'd';
1660 return DECFLOAT;
1661 }
1662
1663 if (! parse_c_float (parse_gdbarch, p, len,
1664 &putithere->typed_val_float.dval,
1665 &putithere->typed_val_float.type))
1666 return ERROR;
1667 return FLOAT;
1668 }
1669
1670 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1671 if (p[0] == '0')
1672 switch (p[1])
1673 {
1674 case 'x':
1675 case 'X':
1676 if (len >= 3)
1677 {
1678 p += 2;
1679 base = 16;
1680 len -= 2;
1681 }
1682 break;
1683
1684 case 'b':
1685 case 'B':
1686 if (len >= 3)
1687 {
1688 p += 2;
1689 base = 2;
1690 len -= 2;
1691 }
1692 break;
1693
1694 case 't':
1695 case 'T':
1696 case 'd':
1697 case 'D':
1698 if (len >= 3)
1699 {
1700 p += 2;
1701 base = 10;
1702 len -= 2;
1703 }
1704 break;
1705
1706 default:
1707 base = 8;
1708 break;
1709 }
1710
1711 while (len-- > 0)
1712 {
1713 c = *p++;
1714 if (c >= 'A' && c <= 'Z')
1715 c += 'a' - 'A';
1716 if (c != 'l' && c != 'u')
1717 n *= base;
1718 if (c >= '0' && c <= '9')
1719 {
1720 if (found_suffix)
1721 return ERROR;
1722 n += i = c - '0';
1723 }
1724 else
1725 {
1726 if (base > 10 && c >= 'a' && c <= 'f')
1727 {
1728 if (found_suffix)
1729 return ERROR;
1730 n += i = c - 'a' + 10;
1731 }
1732 else if (c == 'l')
1733 {
1734 ++long_p;
1735 found_suffix = 1;
1736 }
1737 else if (c == 'u')
1738 {
1739 unsigned_p = 1;
1740 found_suffix = 1;
1741 }
1742 else
1743 return ERROR; /* Char not a digit */
1744 }
1745 if (i >= base)
1746 return ERROR; /* Invalid digit in this base */
1747
1748 /* Portably test for overflow (only works for nonzero values, so make
1749 a second check for zero). FIXME: Can't we just make n and prevn
1750 unsigned and avoid this? */
1751 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1752 unsigned_p = 1; /* Try something unsigned */
1753
1754 /* Portably test for unsigned overflow.
1755 FIXME: This check is wrong; for example it doesn't find overflow
1756 on 0x123456789 when LONGEST is 32 bits. */
1757 if (c != 'l' && c != 'u' && n != 0)
1758 {
1759 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1760 error (_("Numeric constant too large."));
1761 }
1762 prevn = n;
1763 }
1764
1765 /* An integer constant is an int, a long, or a long long. An L
1766 suffix forces it to be long; an LL suffix forces it to be long
1767 long. If not forced to a larger size, it gets the first type of
1768 the above that it fits in. To figure out whether it fits, we
1769 shift it right and see whether anything remains. Note that we
1770 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1771 operation, because many compilers will warn about such a shift
1772 (which always produces a zero result). Sometimes gdbarch_int_bit
1773 or gdbarch_long_bit will be that big, sometimes not. To deal with
1774 the case where it is we just always shift the value more than
1775 once, with fewer bits each time. */
1776
1777 un = (ULONGEST)n >> 2;
1778 if (long_p == 0
1779 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1780 {
1781 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1782
1783 /* A large decimal (not hex or octal) constant (between INT_MAX
1784 and UINT_MAX) is a long or unsigned long, according to ANSI,
1785 never an unsigned int, but this code treats it as unsigned
1786 int. This probably should be fixed. GCC gives a warning on
1787 such constants. */
1788
1789 unsigned_type = parse_type->builtin_unsigned_int;
1790 signed_type = parse_type->builtin_int;
1791 }
1792 else if (long_p <= 1
1793 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1794 {
1795 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1796 unsigned_type = parse_type->builtin_unsigned_long;
1797 signed_type = parse_type->builtin_long;
1798 }
1799 else
1800 {
1801 int shift;
1802 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1803 < gdbarch_long_long_bit (parse_gdbarch))
1804 /* A long long does not fit in a LONGEST. */
1805 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1806 else
1807 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1808 high_bit = (ULONGEST) 1 << shift;
1809 unsigned_type = parse_type->builtin_unsigned_long_long;
1810 signed_type = parse_type->builtin_long_long;
1811 }
1812
1813 putithere->typed_val_int.val = n;
1814
1815 /* If the high bit of the worked out type is set then this number
1816 has to be unsigned. */
1817
1818 if (unsigned_p || (n & high_bit))
1819 {
1820 putithere->typed_val_int.type = unsigned_type;
1821 }
1822 else
1823 {
1824 putithere->typed_val_int.type = signed_type;
1825 }
1826
1827 return INT;
1828 }
1829
1830 /* Temporary obstack used for holding strings. */
1831 static struct obstack tempbuf;
1832 static int tempbuf_init;
1833
1834 /* Parse a C escape sequence. The initial backslash of the sequence
1835 is at (*PTR)[-1]. *PTR will be updated to point to just after the
1836 last character of the sequence. If OUTPUT is not NULL, the
1837 translated form of the escape sequence will be written there. If
1838 OUTPUT is NULL, no output is written and the call will only affect
1839 *PTR. If an escape sequence is expressed in target bytes, then the
1840 entire sequence will simply be copied to OUTPUT. Return 1 if any
1841 character was emitted, 0 otherwise. */
1842
1843 int
1844 c_parse_escape (char **ptr, struct obstack *output)
1845 {
1846 char *tokptr = *ptr;
1847 int result = 1;
1848
1849 /* Some escape sequences undergo character set conversion. Those we
1850 translate here. */
1851 switch (*tokptr)
1852 {
1853 /* Hex escapes do not undergo character set conversion, so keep
1854 the escape sequence for later. */
1855 case 'x':
1856 if (output)
1857 obstack_grow_str (output, "\\x");
1858 ++tokptr;
1859 if (!isxdigit (*tokptr))
1860 error (_("\\x escape without a following hex digit"));
1861 while (isxdigit (*tokptr))
1862 {
1863 if (output)
1864 obstack_1grow (output, *tokptr);
1865 ++tokptr;
1866 }
1867 break;
1868
1869 /* Octal escapes do not undergo character set conversion, so
1870 keep the escape sequence for later. */
1871 case '0':
1872 case '1':
1873 case '2':
1874 case '3':
1875 case '4':
1876 case '5':
1877 case '6':
1878 case '7':
1879 {
1880 int i;
1881 if (output)
1882 obstack_grow_str (output, "\\");
1883 for (i = 0;
1884 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1885 ++i)
1886 {
1887 if (output)
1888 obstack_1grow (output, *tokptr);
1889 ++tokptr;
1890 }
1891 }
1892 break;
1893
1894 /* We handle UCNs later. We could handle them here, but that
1895 would mean a spurious error in the case where the UCN could
1896 be converted to the target charset but not the host
1897 charset. */
1898 case 'u':
1899 case 'U':
1900 {
1901 char c = *tokptr;
1902 int i, len = c == 'U' ? 8 : 4;
1903 if (output)
1904 {
1905 obstack_1grow (output, '\\');
1906 obstack_1grow (output, *tokptr);
1907 }
1908 ++tokptr;
1909 if (!isxdigit (*tokptr))
1910 error (_("\\%c escape without a following hex digit"), c);
1911 for (i = 0; i < len && isxdigit (*tokptr); ++i)
1912 {
1913 if (output)
1914 obstack_1grow (output, *tokptr);
1915 ++tokptr;
1916 }
1917 }
1918 break;
1919
1920 /* We must pass backslash through so that it does not
1921 cause quoting during the second expansion. */
1922 case '\\':
1923 if (output)
1924 obstack_grow_str (output, "\\\\");
1925 ++tokptr;
1926 break;
1927
1928 /* Escapes which undergo conversion. */
1929 case 'a':
1930 if (output)
1931 obstack_1grow (output, '\a');
1932 ++tokptr;
1933 break;
1934 case 'b':
1935 if (output)
1936 obstack_1grow (output, '\b');
1937 ++tokptr;
1938 break;
1939 case 'f':
1940 if (output)
1941 obstack_1grow (output, '\f');
1942 ++tokptr;
1943 break;
1944 case 'n':
1945 if (output)
1946 obstack_1grow (output, '\n');
1947 ++tokptr;
1948 break;
1949 case 'r':
1950 if (output)
1951 obstack_1grow (output, '\r');
1952 ++tokptr;
1953 break;
1954 case 't':
1955 if (output)
1956 obstack_1grow (output, '\t');
1957 ++tokptr;
1958 break;
1959 case 'v':
1960 if (output)
1961 obstack_1grow (output, '\v');
1962 ++tokptr;
1963 break;
1964
1965 /* GCC extension. */
1966 case 'e':
1967 if (output)
1968 obstack_1grow (output, HOST_ESCAPE_CHAR);
1969 ++tokptr;
1970 break;
1971
1972 /* Backslash-newline expands to nothing at all. */
1973 case '\n':
1974 ++tokptr;
1975 result = 0;
1976 break;
1977
1978 /* A few escapes just expand to the character itself. */
1979 case '\'':
1980 case '\"':
1981 case '?':
1982 /* GCC extensions. */
1983 case '(':
1984 case '{':
1985 case '[':
1986 case '%':
1987 /* Unrecognized escapes turn into the character itself. */
1988 default:
1989 if (output)
1990 obstack_1grow (output, *tokptr);
1991 ++tokptr;
1992 break;
1993 }
1994 *ptr = tokptr;
1995 return result;
1996 }
1997
1998 /* Parse a string or character literal from TOKPTR. The string or
1999 character may be wide or unicode. *OUTPTR is set to just after the
2000 end of the literal in the input string. The resulting token is
2001 stored in VALUE. This returns a token value, either STRING or
2002 CHAR, depending on what was parsed. *HOST_CHARS is set to the
2003 number of host characters in the literal. */
2004 static int
2005 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
2006 int *host_chars)
2007 {
2008 int quote;
2009 enum c_string_type type;
2010 int is_objc = 0;
2011
2012 /* Build the gdb internal form of the input string in tempbuf. Note
2013 that the buffer is null byte terminated *only* for the
2014 convenience of debugging gdb itself and printing the buffer
2015 contents when the buffer contains no embedded nulls. Gdb does
2016 not depend upon the buffer being null byte terminated, it uses
2017 the length string instead. This allows gdb to handle C strings
2018 (as well as strings in other languages) with embedded null
2019 bytes */
2020
2021 if (!tempbuf_init)
2022 tempbuf_init = 1;
2023 else
2024 obstack_free (&tempbuf, NULL);
2025 obstack_init (&tempbuf);
2026
2027 /* Record the string type. */
2028 if (*tokptr == 'L')
2029 {
2030 type = C_WIDE_STRING;
2031 ++tokptr;
2032 }
2033 else if (*tokptr == 'u')
2034 {
2035 type = C_STRING_16;
2036 ++tokptr;
2037 }
2038 else if (*tokptr == 'U')
2039 {
2040 type = C_STRING_32;
2041 ++tokptr;
2042 }
2043 else if (*tokptr == '@')
2044 {
2045 /* An Objective C string. */
2046 is_objc = 1;
2047 type = C_STRING;
2048 ++tokptr;
2049 }
2050 else
2051 type = C_STRING;
2052
2053 /* Skip the quote. */
2054 quote = *tokptr;
2055 if (quote == '\'')
2056 type |= C_CHAR;
2057 ++tokptr;
2058
2059 *host_chars = 0;
2060
2061 while (*tokptr)
2062 {
2063 char c = *tokptr;
2064 if (c == '\\')
2065 {
2066 ++tokptr;
2067 *host_chars += c_parse_escape (&tokptr, &tempbuf);
2068 }
2069 else if (c == quote)
2070 break;
2071 else
2072 {
2073 obstack_1grow (&tempbuf, c);
2074 ++tokptr;
2075 /* FIXME: this does the wrong thing with multi-byte host
2076 characters. We could use mbrlen here, but that would
2077 make "set host-charset" a bit less useful. */
2078 ++*host_chars;
2079 }
2080 }
2081
2082 if (*tokptr != quote)
2083 {
2084 if (quote == '"')
2085 error (_("Unterminated string in expression."));
2086 else
2087 error (_("Unmatched single quote."));
2088 }
2089 ++tokptr;
2090
2091 value->type = type;
2092 value->ptr = obstack_base (&tempbuf);
2093 value->length = obstack_object_size (&tempbuf);
2094
2095 *outptr = tokptr;
2096
2097 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2098 }
2099
2100 /* This is used to associate some attributes with a token. */
2101
2102 enum token_flags
2103 {
2104 /* If this bit is set, the token is C++-only. */
2105
2106 FLAG_CXX = 1,
2107
2108 /* If this bit is set, the token is conditional: if there is a
2109 symbol of the same name, then the token is a symbol; otherwise,
2110 the token is a keyword. */
2111
2112 FLAG_SHADOW = 2
2113 };
2114
2115 struct token
2116 {
2117 char *operator;
2118 int token;
2119 enum exp_opcode opcode;
2120 enum token_flags flags;
2121 };
2122
2123 static const struct token tokentab3[] =
2124 {
2125 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2126 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2127 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2128 {"...", DOTDOTDOT, BINOP_END, 0}
2129 };
2130
2131 static const struct token tokentab2[] =
2132 {
2133 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2134 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2135 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2136 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2137 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2138 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2139 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2140 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2141 {"++", INCREMENT, BINOP_END, 0},
2142 {"--", DECREMENT, BINOP_END, 0},
2143 {"->", ARROW, BINOP_END, 0},
2144 {"&&", ANDAND, BINOP_END, 0},
2145 {"||", OROR, BINOP_END, 0},
2146 /* "::" is *not* only C++: gdb overrides its meaning in several
2147 different ways, e.g., 'filename'::func, function::variable. */
2148 {"::", COLONCOLON, BINOP_END, 0},
2149 {"<<", LSH, BINOP_END, 0},
2150 {">>", RSH, BINOP_END, 0},
2151 {"==", EQUAL, BINOP_END, 0},
2152 {"!=", NOTEQUAL, BINOP_END, 0},
2153 {"<=", LEQ, BINOP_END, 0},
2154 {">=", GEQ, BINOP_END, 0},
2155 {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2156 };
2157
2158 /* Identifier-like tokens. */
2159 static const struct token ident_tokens[] =
2160 {
2161 {"unsigned", UNSIGNED, OP_NULL, 0},
2162 {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2163 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2164 {"struct", STRUCT, OP_NULL, 0},
2165 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2166 {"sizeof", SIZEOF, OP_NULL, 0},
2167 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2168 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2169 {"class", CLASS, OP_NULL, FLAG_CXX},
2170 {"union", UNION, OP_NULL, 0},
2171 {"short", SHORT, OP_NULL, 0},
2172 {"const", CONST_KEYWORD, OP_NULL, 0},
2173 {"enum", ENUM, OP_NULL, 0},
2174 {"long", LONG, OP_NULL, 0},
2175 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2176 {"int", INT_KEYWORD, OP_NULL, 0},
2177 {"new", NEW, OP_NULL, FLAG_CXX},
2178 {"delete", DELETE, OP_NULL, FLAG_CXX},
2179 {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2180
2181 {"and", ANDAND, BINOP_END, FLAG_CXX},
2182 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2183 {"bitand", '&', OP_NULL, FLAG_CXX},
2184 {"bitor", '|', OP_NULL, FLAG_CXX},
2185 {"compl", '~', OP_NULL, FLAG_CXX},
2186 {"not", '!', OP_NULL, FLAG_CXX},
2187 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2188 {"or", OROR, BINOP_END, FLAG_CXX},
2189 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2190 {"xor", '^', OP_NULL, FLAG_CXX},
2191 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2192
2193 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2194 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2195 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2196 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2197
2198 {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2199 {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2200 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2201 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2202 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW }
2203 };
2204
2205 /* When we find that lexptr (the global var defined in parse.c) is
2206 pointing at a macro invocation, we expand the invocation, and call
2207 scan_macro_expansion to save the old lexptr here and point lexptr
2208 into the expanded text. When we reach the end of that, we call
2209 end_macro_expansion to pop back to the value we saved here. The
2210 macro expansion code promises to return only fully-expanded text,
2211 so we don't need to "push" more than one level.
2212
2213 This is disgusting, of course. It would be cleaner to do all macro
2214 expansion beforehand, and then hand that to lexptr. But we don't
2215 really know where the expression ends. Remember, in a command like
2216
2217 (gdb) break *ADDRESS if CONDITION
2218
2219 we evaluate ADDRESS in the scope of the current frame, but we
2220 evaluate CONDITION in the scope of the breakpoint's location. So
2221 it's simply wrong to try to macro-expand the whole thing at once. */
2222 static char *macro_original_text;
2223
2224 /* We save all intermediate macro expansions on this obstack for the
2225 duration of a single parse. The expansion text may sometimes have
2226 to live past the end of the expansion, due to yacc lookahead.
2227 Rather than try to be clever about saving the data for a single
2228 token, we simply keep it all and delete it after parsing has
2229 completed. */
2230 static struct obstack expansion_obstack;
2231
2232 static void
2233 scan_macro_expansion (char *expansion)
2234 {
2235 char *copy;
2236
2237 /* We'd better not be trying to push the stack twice. */
2238 gdb_assert (! macro_original_text);
2239
2240 /* Copy to the obstack, and then free the intermediate
2241 expansion. */
2242 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
2243 xfree (expansion);
2244
2245 /* Save the old lexptr value, so we can return to it when we're done
2246 parsing the expanded text. */
2247 macro_original_text = lexptr;
2248 lexptr = copy;
2249 }
2250
2251
2252 static int
2253 scanning_macro_expansion (void)
2254 {
2255 return macro_original_text != 0;
2256 }
2257
2258
2259 static void
2260 finished_macro_expansion (void)
2261 {
2262 /* There'd better be something to pop back to. */
2263 gdb_assert (macro_original_text);
2264
2265 /* Pop back to the original text. */
2266 lexptr = macro_original_text;
2267 macro_original_text = 0;
2268 }
2269
2270
2271 static void
2272 scan_macro_cleanup (void *dummy)
2273 {
2274 if (macro_original_text)
2275 finished_macro_expansion ();
2276
2277 obstack_free (&expansion_obstack, NULL);
2278 }
2279
2280 /* Return true iff the token represents a C++ cast operator. */
2281
2282 static int
2283 is_cast_operator (const char *token, int len)
2284 {
2285 return (! strncmp (token, "dynamic_cast", len)
2286 || ! strncmp (token, "static_cast", len)
2287 || ! strncmp (token, "reinterpret_cast", len)
2288 || ! strncmp (token, "const_cast", len));
2289 }
2290
2291 /* The scope used for macro expansion. */
2292 static struct macro_scope *expression_macro_scope;
2293
2294 /* This is set if a NAME token appeared at the very end of the input
2295 string, with no whitespace separating the name from the EOF. This
2296 is used only when parsing to do field name completion. */
2297 static int saw_name_at_eof;
2298
2299 /* This is set if the previously-returned token was a structure
2300 operator -- either '.' or ARROW. This is used only when parsing to
2301 do field name completion. */
2302 static int last_was_structop;
2303
2304 /* Read one token, getting characters through lexptr. */
2305
2306 static int
2307 lex_one_token (void)
2308 {
2309 int c;
2310 int namelen;
2311 unsigned int i;
2312 char *tokstart;
2313 int saw_structop = last_was_structop;
2314 char *copy;
2315
2316 last_was_structop = 0;
2317
2318 retry:
2319
2320 /* Check if this is a macro invocation that we need to expand. */
2321 if (! scanning_macro_expansion ())
2322 {
2323 char *expanded = macro_expand_next (&lexptr,
2324 standard_macro_lookup,
2325 expression_macro_scope);
2326
2327 if (expanded)
2328 scan_macro_expansion (expanded);
2329 }
2330
2331 prev_lexptr = lexptr;
2332
2333 tokstart = lexptr;
2334 /* See if it is a special token of length 3. */
2335 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2336 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2337 {
2338 if ((tokentab3[i].flags & FLAG_CXX) != 0
2339 && parse_language->la_language != language_cplus)
2340 break;
2341
2342 lexptr += 3;
2343 yylval.opcode = tokentab3[i].opcode;
2344 return tokentab3[i].token;
2345 }
2346
2347 /* See if it is a special token of length 2. */
2348 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2349 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2350 {
2351 if ((tokentab2[i].flags & FLAG_CXX) != 0
2352 && parse_language->la_language != language_cplus)
2353 break;
2354
2355 lexptr += 2;
2356 yylval.opcode = tokentab2[i].opcode;
2357 if (in_parse_field && tokentab2[i].token == ARROW)
2358 last_was_structop = 1;
2359 return tokentab2[i].token;
2360 }
2361
2362 switch (c = *tokstart)
2363 {
2364 case 0:
2365 /* If we were just scanning the result of a macro expansion,
2366 then we need to resume scanning the original text.
2367 If we're parsing for field name completion, and the previous
2368 token allows such completion, return a COMPLETE token.
2369 Otherwise, we were already scanning the original text, and
2370 we're really done. */
2371 if (scanning_macro_expansion ())
2372 {
2373 finished_macro_expansion ();
2374 goto retry;
2375 }
2376 else if (saw_name_at_eof)
2377 {
2378 saw_name_at_eof = 0;
2379 return COMPLETE;
2380 }
2381 else if (saw_structop)
2382 return COMPLETE;
2383 else
2384 return 0;
2385
2386 case ' ':
2387 case '\t':
2388 case '\n':
2389 lexptr++;
2390 goto retry;
2391
2392 case '[':
2393 case '(':
2394 paren_depth++;
2395 lexptr++;
2396 if (parse_language->la_language == language_objc && c == '[')
2397 return OBJC_LBRAC;
2398 return c;
2399
2400 case ']':
2401 case ')':
2402 if (paren_depth == 0)
2403 return 0;
2404 paren_depth--;
2405 lexptr++;
2406 return c;
2407
2408 case ',':
2409 if (comma_terminates
2410 && paren_depth == 0
2411 && ! scanning_macro_expansion ())
2412 return 0;
2413 lexptr++;
2414 return c;
2415
2416 case '.':
2417 /* Might be a floating point number. */
2418 if (lexptr[1] < '0' || lexptr[1] > '9')
2419 {
2420 if (in_parse_field)
2421 last_was_structop = 1;
2422 goto symbol; /* Nope, must be a symbol. */
2423 }
2424 /* FALL THRU into number case. */
2425
2426 case '0':
2427 case '1':
2428 case '2':
2429 case '3':
2430 case '4':
2431 case '5':
2432 case '6':
2433 case '7':
2434 case '8':
2435 case '9':
2436 {
2437 /* It's a number. */
2438 int got_dot = 0, got_e = 0, toktype;
2439 char *p = tokstart;
2440 int hex = input_radix > 10;
2441
2442 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2443 {
2444 p += 2;
2445 hex = 1;
2446 }
2447 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2448 {
2449 p += 2;
2450 hex = 0;
2451 }
2452
2453 for (;; ++p)
2454 {
2455 /* This test includes !hex because 'e' is a valid hex digit
2456 and thus does not indicate a floating point number when
2457 the radix is hex. */
2458 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2459 got_dot = got_e = 1;
2460 /* This test does not include !hex, because a '.' always indicates
2461 a decimal floating point number regardless of the radix. */
2462 else if (!got_dot && *p == '.')
2463 got_dot = 1;
2464 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2465 && (*p == '-' || *p == '+'))
2466 /* This is the sign of the exponent, not the end of the
2467 number. */
2468 continue;
2469 /* We will take any letters or digits. parse_number will
2470 complain if past the radix, or if L or U are not final. */
2471 else if ((*p < '0' || *p > '9')
2472 && ((*p < 'a' || *p > 'z')
2473 && (*p < 'A' || *p > 'Z')))
2474 break;
2475 }
2476 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2477 if (toktype == ERROR)
2478 {
2479 char *err_copy = (char *) alloca (p - tokstart + 1);
2480
2481 memcpy (err_copy, tokstart, p - tokstart);
2482 err_copy[p - tokstart] = 0;
2483 error (_("Invalid number \"%s\"."), err_copy);
2484 }
2485 lexptr = p;
2486 return toktype;
2487 }
2488
2489 case '@':
2490 {
2491 char *p = &tokstart[1];
2492 size_t len = strlen ("entry");
2493
2494 if (parse_language->la_language == language_objc)
2495 {
2496 size_t len = strlen ("selector");
2497
2498 if (strncmp (p, "selector", len) == 0
2499 && (p[len] == '\0' || isspace (p[len])))
2500 {
2501 lexptr = p + len;
2502 return SELECTOR;
2503 }
2504 else if (*p == '"')
2505 goto parse_string;
2506 }
2507
2508 while (isspace (*p))
2509 p++;
2510 if (strncmp (p, "entry", len) == 0 && !isalnum (p[len])
2511 && p[len] != '_')
2512 {
2513 lexptr = &p[len];
2514 return ENTRY;
2515 }
2516 }
2517 /* FALLTHRU */
2518 case '+':
2519 case '-':
2520 case '*':
2521 case '/':
2522 case '%':
2523 case '|':
2524 case '&':
2525 case '^':
2526 case '~':
2527 case '!':
2528 case '<':
2529 case '>':
2530 case '?':
2531 case ':':
2532 case '=':
2533 case '{':
2534 case '}':
2535 symbol:
2536 lexptr++;
2537 return c;
2538
2539 case 'L':
2540 case 'u':
2541 case 'U':
2542 if (tokstart[1] != '"' && tokstart[1] != '\'')
2543 break;
2544 /* Fall through. */
2545 case '\'':
2546 case '"':
2547
2548 parse_string:
2549 {
2550 int host_len;
2551 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2552 &host_len);
2553 if (result == CHAR)
2554 {
2555 if (host_len == 0)
2556 error (_("Empty character constant."));
2557 else if (host_len > 2 && c == '\'')
2558 {
2559 ++tokstart;
2560 namelen = lexptr - tokstart - 1;
2561 goto tryname;
2562 }
2563 else if (host_len > 1)
2564 error (_("Invalid character constant."));
2565 }
2566 return result;
2567 }
2568 }
2569
2570 if (!(c == '_' || c == '$'
2571 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2572 /* We must have come across a bad character (e.g. ';'). */
2573 error (_("Invalid character '%c' in expression."), c);
2574
2575 /* It's a name. See how long it is. */
2576 namelen = 0;
2577 for (c = tokstart[namelen];
2578 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2579 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2580 {
2581 /* Template parameter lists are part of the name.
2582 FIXME: This mishandles `print $a<4&&$a>3'. */
2583
2584 if (c == '<')
2585 {
2586 if (! is_cast_operator (tokstart, namelen))
2587 {
2588 /* Scan ahead to get rest of the template specification. Note
2589 that we look ahead only when the '<' adjoins non-whitespace
2590 characters; for comparison expressions, e.g. "a < b > c",
2591 there must be spaces before the '<', etc. */
2592
2593 char * p = find_template_name_end (tokstart + namelen);
2594 if (p)
2595 namelen = p - tokstart;
2596 }
2597 break;
2598 }
2599 c = tokstart[++namelen];
2600 }
2601
2602 /* The token "if" terminates the expression and is NOT removed from
2603 the input stream. It doesn't count if it appears in the
2604 expansion of a macro. */
2605 if (namelen == 2
2606 && tokstart[0] == 'i'
2607 && tokstart[1] == 'f'
2608 && ! scanning_macro_expansion ())
2609 {
2610 return 0;
2611 }
2612
2613 /* For the same reason (breakpoint conditions), "thread N"
2614 terminates the expression. "thread" could be an identifier, but
2615 an identifier is never followed by a number without intervening
2616 punctuation. "task" is similar. Handle abbreviations of these,
2617 similarly to breakpoint.c:find_condition_and_thread. */
2618 if (namelen >= 1
2619 && (strncmp (tokstart, "thread", namelen) == 0
2620 || strncmp (tokstart, "task", namelen) == 0)
2621 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2622 && ! scanning_macro_expansion ())
2623 {
2624 char *p = tokstart + namelen + 1;
2625 while (*p == ' ' || *p == '\t')
2626 p++;
2627 if (*p >= '0' && *p <= '9')
2628 return 0;
2629 }
2630
2631 lexptr += namelen;
2632
2633 tryname:
2634
2635 yylval.sval.ptr = tokstart;
2636 yylval.sval.length = namelen;
2637
2638 /* Catch specific keywords. */
2639 copy = copy_name (yylval.sval);
2640 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2641 if (strcmp (copy, ident_tokens[i].operator) == 0)
2642 {
2643 if ((ident_tokens[i].flags & FLAG_CXX) != 0
2644 && parse_language->la_language != language_cplus)
2645 break;
2646
2647 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2648 {
2649 int is_a_field_of_this = 0;
2650
2651 if (lookup_symbol (copy, expression_context_block,
2652 VAR_DOMAIN,
2653 (parse_language->la_language == language_cplus
2654 ? &is_a_field_of_this
2655 : NULL))
2656 != NULL)
2657 {
2658 /* The keyword is shadowed. */
2659 break;
2660 }
2661 }
2662
2663 /* It is ok to always set this, even though we don't always
2664 strictly need to. */
2665 yylval.opcode = ident_tokens[i].opcode;
2666 return ident_tokens[i].token;
2667 }
2668
2669 if (*tokstart == '$')
2670 return VARIABLE;
2671
2672 if (in_parse_field && *lexptr == '\0')
2673 saw_name_at_eof = 1;
2674 return NAME;
2675 }
2676
2677 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
2678 typedef struct
2679 {
2680 int token;
2681 YYSTYPE value;
2682 } token_and_value;
2683
2684 DEF_VEC_O (token_and_value);
2685
2686 /* A FIFO of tokens that have been read but not yet returned to the
2687 parser. */
2688 static VEC (token_and_value) *token_fifo;
2689
2690 /* Non-zero if the lexer should return tokens from the FIFO. */
2691 static int popping;
2692
2693 /* Temporary storage for c_lex; this holds symbol names as they are
2694 built up. */
2695 static struct obstack name_obstack;
2696
2697 /* Classify a NAME token. The contents of the token are in `yylval'.
2698 Updates yylval and returns the new token type. BLOCK is the block
2699 in which lookups start; this can be NULL to mean the global
2700 scope. */
2701 static int
2702 classify_name (const struct block *block)
2703 {
2704 struct symbol *sym;
2705 char *copy;
2706 int is_a_field_of_this = 0;
2707
2708 copy = copy_name (yylval.sval);
2709
2710 sym = lookup_symbol (copy, block, VAR_DOMAIN,
2711 parse_language->la_name_of_this
2712 ? &is_a_field_of_this : (int *) NULL);
2713
2714 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2715 {
2716 yylval.ssym.sym = sym;
2717 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2718 return BLOCKNAME;
2719 }
2720 else if (!sym)
2721 {
2722 /* See if it's a file name. */
2723 struct symtab *symtab;
2724
2725 symtab = lookup_symtab (copy);
2726 if (symtab)
2727 {
2728 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2729 return FILENAME;
2730 }
2731 }
2732
2733 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2734 {
2735 yylval.tsym.type = SYMBOL_TYPE (sym);
2736 return TYPENAME;
2737 }
2738
2739 yylval.tsym.type
2740 = language_lookup_primitive_type_by_name (parse_language,
2741 parse_gdbarch, copy);
2742 if (yylval.tsym.type != NULL)
2743 return TYPENAME;
2744
2745 /* See if it's an ObjC classname. */
2746 if (parse_language->la_language == language_objc && !sym)
2747 {
2748 CORE_ADDR Class = lookup_objc_class (parse_gdbarch, copy);
2749 if (Class)
2750 {
2751 yylval.class.class = Class;
2752 sym = lookup_struct_typedef (copy, expression_context_block, 1);
2753 if (sym)
2754 yylval.class.type = SYMBOL_TYPE (sym);
2755 return CLASSNAME;
2756 }
2757 }
2758
2759 /* Input names that aren't symbols but ARE valid hex numbers, when
2760 the input radix permits them, can be names or numbers depending
2761 on the parse. Note we support radixes > 16 here. */
2762 if (!sym
2763 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2764 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2765 {
2766 YYSTYPE newlval; /* Its value is ignored. */
2767 int hextype = parse_number (copy, yylval.sval.length, 0, &newlval);
2768 if (hextype == INT)
2769 {
2770 yylval.ssym.sym = sym;
2771 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2772 return NAME_OR_INT;
2773 }
2774 }
2775
2776 /* Any other kind of symbol */
2777 yylval.ssym.sym = sym;
2778 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2779
2780 if (sym == NULL
2781 && parse_language->la_language == language_cplus
2782 && !is_a_field_of_this
2783 && !lookup_minimal_symbol (copy, NULL, NULL))
2784 return UNKNOWN_CPP_NAME;
2785
2786 return NAME;
2787 }
2788
2789 /* Like classify_name, but used by the inner loop of the lexer, when a
2790 name might have already been seen. FIRST_NAME is true if the token
2791 in `yylval' is the first component of a name, false otherwise. */
2792
2793 static int
2794 classify_inner_name (const struct block *block, int first_name)
2795 {
2796 struct type *type, *new_type;
2797 char *copy;
2798
2799 if (first_name)
2800 return classify_name (block);
2801
2802 type = check_typedef (yylval.tsym.type);
2803 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
2804 && TYPE_CODE (type) != TYPE_CODE_UNION
2805 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
2806 return ERROR;
2807
2808 copy = copy_name (yylval.tsym.stoken);
2809 yylval.ssym.sym = cp_lookup_nested_symbol (yylval.tsym.type, copy, block);
2810 if (yylval.ssym.sym == NULL)
2811 return ERROR;
2812
2813 switch (SYMBOL_CLASS (yylval.ssym.sym))
2814 {
2815 case LOC_BLOCK:
2816 case LOC_LABEL:
2817 return ERROR;
2818
2819 case LOC_TYPEDEF:
2820 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym);;
2821 return TYPENAME;
2822
2823 default:
2824 yylval.ssym.is_a_field_of_this = 0;
2825 return NAME;
2826 }
2827 internal_error (__FILE__, __LINE__, _("not reached"));
2828 }
2829
2830 /* The outer level of a two-level lexer. This calls the inner lexer
2831 to return tokens. It then either returns these tokens, or
2832 aggregates them into a larger token. This lets us work around a
2833 problem in our parsing approach, where the parser could not
2834 distinguish between qualified names and qualified types at the
2835 right point.
2836
2837 This approach is still not ideal, because it mishandles template
2838 types. See the comment in lex_one_token for an example. However,
2839 this is still an improvement over the earlier approach, and will
2840 suffice until we move to better parsing technology. */
2841 static int
2842 yylex (void)
2843 {
2844 token_and_value current;
2845 int first_was_coloncolon, last_was_coloncolon, first_iter;
2846
2847 if (popping && !VEC_empty (token_and_value, token_fifo))
2848 {
2849 token_and_value tv = *VEC_index (token_and_value, token_fifo, 0);
2850 VEC_ordered_remove (token_and_value, token_fifo, 0);
2851 yylval = tv.value;
2852 return tv.token;
2853 }
2854 popping = 0;
2855
2856 current.token = lex_one_token ();
2857 if (current.token == NAME)
2858 current.token = classify_name (expression_context_block);
2859 if (parse_language->la_language != language_cplus
2860 || (current.token != TYPENAME && current.token != COLONCOLON))
2861 return current.token;
2862
2863 first_was_coloncolon = current.token == COLONCOLON;
2864 last_was_coloncolon = first_was_coloncolon;
2865 obstack_free (&name_obstack, obstack_base (&name_obstack));
2866 if (!last_was_coloncolon)
2867 obstack_grow (&name_obstack, yylval.sval.ptr, yylval.sval.length);
2868 current.value = yylval;
2869 first_iter = 1;
2870 while (1)
2871 {
2872 token_and_value next;
2873
2874 next.token = lex_one_token ();
2875 next.value = yylval;
2876
2877 if (next.token == NAME && last_was_coloncolon)
2878 {
2879 int classification;
2880
2881 classification = classify_inner_name (first_was_coloncolon
2882 ? NULL
2883 : expression_context_block,
2884 first_iter);
2885 /* We keep going until we either run out of names, or until
2886 we have a qualified name which is not a type. */
2887 if (classification != TYPENAME && classification != NAME)
2888 {
2889 /* Push the final component and leave the loop. */
2890 VEC_safe_push (token_and_value, token_fifo, &next);
2891 break;
2892 }
2893
2894 /* Update the partial name we are constructing. */
2895 if (!first_iter)
2896 {
2897 /* We don't want to put a leading "::" into the name. */
2898 obstack_grow_str (&name_obstack, "::");
2899 }
2900 obstack_grow (&name_obstack, next.value.sval.ptr,
2901 next.value.sval.length);
2902
2903 yylval.sval.ptr = obstack_base (&name_obstack);
2904 yylval.sval.length = obstack_object_size (&name_obstack);
2905 current.value = yylval;
2906 current.token = classification;
2907
2908 last_was_coloncolon = 0;
2909 }
2910 else if (next.token == COLONCOLON && !last_was_coloncolon)
2911 last_was_coloncolon = 1;
2912 else
2913 {
2914 /* We've reached the end of the name. */
2915 VEC_safe_push (token_and_value, token_fifo, &next);
2916 break;
2917 }
2918
2919 first_iter = 0;
2920 }
2921
2922 popping = 1;
2923
2924 /* If we ended with a "::", insert it too. */
2925 if (last_was_coloncolon)
2926 {
2927 token_and_value cc;
2928 memset (&cc, 0, sizeof (token_and_value));
2929 if (first_was_coloncolon && first_iter)
2930 {
2931 yylval = cc.value;
2932 return COLONCOLON;
2933 }
2934 cc.token = COLONCOLON;
2935 VEC_safe_insert (token_and_value, token_fifo, 0, &cc);
2936 }
2937
2938 yylval = current.value;
2939 yylval.sval.ptr = obstack_copy0 (&expansion_obstack,
2940 yylval.sval.ptr,
2941 yylval.sval.length);
2942 return current.token;
2943 }
2944
2945 int
2946 c_parse (void)
2947 {
2948 int result;
2949 struct cleanup *back_to = make_cleanup (free_current_contents,
2950 &expression_macro_scope);
2951
2952 /* Set up the scope for macro expansion. */
2953 expression_macro_scope = NULL;
2954
2955 if (expression_context_block)
2956 expression_macro_scope
2957 = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2958 else
2959 expression_macro_scope = default_macro_scope ();
2960 if (! expression_macro_scope)
2961 expression_macro_scope = user_macro_scope ();
2962
2963 /* Initialize macro expansion code. */
2964 obstack_init (&expansion_obstack);
2965 gdb_assert (! macro_original_text);
2966 make_cleanup (scan_macro_cleanup, 0);
2967
2968 make_cleanup_restore_integer (&yydebug);
2969 yydebug = parser_debug;
2970
2971 /* Initialize some state used by the lexer. */
2972 last_was_structop = 0;
2973 saw_name_at_eof = 0;
2974
2975 VEC_free (token_and_value, token_fifo);
2976 popping = 0;
2977 obstack_init (&name_obstack);
2978 make_cleanup_obstack_free (&name_obstack);
2979
2980 result = yyparse ();
2981 do_cleanups (back_to);
2982 return result;
2983 }
2984
2985
2986 void
2987 yyerror (char *msg)
2988 {
2989 if (prev_lexptr)
2990 lexptr = prev_lexptr;
2991
2992 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);
2993 }
GDB Binutils - Deliverables
This page took 0.11859 seconds and 4 git commands to generate.