projects / binutils-gdb.git / blob
? search:


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