projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Move 'is_regular_file' from common-utils.c to filestuff.c
[deliverable/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 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
1228 : TYPENAME
1229 { $$ = $1.type; }
1230 | INT_KEYWORD
1231 { $$ = lookup_signed_typename (parse_language (pstate),
1232 parse_gdbarch (pstate),
1233 "int"); }
1234 | LONG
1235 { $$ = lookup_signed_typename (parse_language (pstate),
1236 parse_gdbarch (pstate),
1237 "long"); }
1238 | SHORT
1239 { $$ = lookup_signed_typename (parse_language (pstate),
1240 parse_gdbarch (pstate),
1241 "short"); }
1242 | LONG INT_KEYWORD
1243 { $$ = lookup_signed_typename (parse_language (pstate),
1244 parse_gdbarch (pstate),
1245 "long"); }
1246 | LONG SIGNED_KEYWORD INT_KEYWORD
1247 { $$ = lookup_signed_typename (parse_language (pstate),
1248 parse_gdbarch (pstate),
1249 "long"); }
1250 | LONG SIGNED_KEYWORD
1251 { $$ = lookup_signed_typename (parse_language (pstate),
1252 parse_gdbarch (pstate),
1253 "long"); }
1254 | SIGNED_KEYWORD LONG INT_KEYWORD
1255 { $$ = lookup_signed_typename (parse_language (pstate),
1256 parse_gdbarch (pstate),
1257 "long"); }
1258 | UNSIGNED LONG INT_KEYWORD
1259 { $$ = lookup_unsigned_typename (parse_language (pstate),
1260 parse_gdbarch (pstate),
1261 "long"); }
1262 | LONG UNSIGNED INT_KEYWORD
1263 { $$ = lookup_unsigned_typename (parse_language (pstate),
1264 parse_gdbarch (pstate),
1265 "long"); }
1266 | LONG UNSIGNED
1267 { $$ = lookup_unsigned_typename (parse_language (pstate),
1268 parse_gdbarch (pstate),
1269 "long"); }
1270 | LONG LONG
1271 { $$ = lookup_signed_typename (parse_language (pstate),
1272 parse_gdbarch (pstate),
1273 "long long"); }
1274 | LONG LONG INT_KEYWORD
1275 { $$ = lookup_signed_typename (parse_language (pstate),
1276 parse_gdbarch (pstate),
1277 "long long"); }
1278 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
1279 { $$ = lookup_signed_typename (parse_language (pstate),
1280 parse_gdbarch (pstate),
1281 "long long"); }
1282 | LONG LONG SIGNED_KEYWORD
1283 { $$ = lookup_signed_typename (parse_language (pstate),
1284 parse_gdbarch (pstate),
1285 "long long"); }
1286 | SIGNED_KEYWORD LONG LONG
1287 { $$ = lookup_signed_typename (parse_language (pstate),
1288 parse_gdbarch (pstate),
1289 "long long"); }
1290 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
1291 { $$ = lookup_signed_typename (parse_language (pstate),
1292 parse_gdbarch (pstate),
1293 "long long"); }
1294 | UNSIGNED LONG LONG
1295 { $$ = lookup_unsigned_typename (parse_language (pstate),
1296 parse_gdbarch (pstate),
1297 "long long"); }
1298 | UNSIGNED LONG LONG INT_KEYWORD
1299 { $$ = lookup_unsigned_typename (parse_language (pstate),
1300 parse_gdbarch (pstate),
1301 "long long"); }
1302 | LONG LONG UNSIGNED
1303 { $$ = lookup_unsigned_typename (parse_language (pstate),
1304 parse_gdbarch (pstate),
1305 "long long"); }
1306 | LONG LONG UNSIGNED INT_KEYWORD
1307 { $$ = lookup_unsigned_typename (parse_language (pstate),
1308 parse_gdbarch (pstate),
1309 "long long"); }
1310 | SHORT INT_KEYWORD
1311 { $$ = lookup_signed_typename (parse_language (pstate),
1312 parse_gdbarch (pstate),
1313 "short"); }
1314 | SHORT SIGNED_KEYWORD INT_KEYWORD
1315 { $$ = lookup_signed_typename (parse_language (pstate),
1316 parse_gdbarch (pstate),
1317 "short"); }
1318 | SHORT SIGNED_KEYWORD
1319 { $$ = lookup_signed_typename (parse_language (pstate),
1320 parse_gdbarch (pstate),
1321 "short"); }
1322 | UNSIGNED SHORT INT_KEYWORD
1323 { $$ = lookup_unsigned_typename (parse_language (pstate),
1324 parse_gdbarch (pstate),
1325 "short"); }
1326 | SHORT UNSIGNED
1327 { $$ = lookup_unsigned_typename (parse_language (pstate),
1328 parse_gdbarch (pstate),
1329 "short"); }
1330 | SHORT UNSIGNED INT_KEYWORD
1331 { $$ = lookup_unsigned_typename (parse_language (pstate),
1332 parse_gdbarch (pstate),
1333 "short"); }
1334 | DOUBLE_KEYWORD
1335 { $$ = lookup_typename (parse_language (pstate),
1336 parse_gdbarch (pstate),
1337 "double",
1338 (struct block *) NULL,
1339 0); }
1340 | LONG DOUBLE_KEYWORD
1341 { $$ = lookup_typename (parse_language (pstate),
1342 parse_gdbarch (pstate),
1343 "long double",
1344 (struct block *) NULL,
1345 0); }
1346 | STRUCT name
1347 { $$ = lookup_struct (copy_name ($2),
1348 expression_context_block); }
1349 | STRUCT COMPLETE
1350 {
1351 mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
1352 $$ = NULL;
1353 }
1354 | STRUCT name COMPLETE
1355 {
1356 mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
1357 $2.length);
1358 $$ = NULL;
1359 }
1360 | CLASS name
1361 { $$ = lookup_struct (copy_name ($2),
1362 expression_context_block); }
1363 | CLASS COMPLETE
1364 {
1365 mark_completion_tag (TYPE_CODE_STRUCT, "", 0);
1366 $$ = NULL;
1367 }
1368 | CLASS name COMPLETE
1369 {
1370 mark_completion_tag (TYPE_CODE_STRUCT, $2.ptr,
1371 $2.length);
1372 $$ = NULL;
1373 }
1374 | UNION name
1375 { $$ = lookup_union (copy_name ($2),
1376 expression_context_block); }
1377 | UNION COMPLETE
1378 {
1379 mark_completion_tag (TYPE_CODE_UNION, "", 0);
1380 $$ = NULL;
1381 }
1382 | UNION name COMPLETE
1383 {
1384 mark_completion_tag (TYPE_CODE_UNION, $2.ptr,
1385 $2.length);
1386 $$ = NULL;
1387 }
1388 | ENUM name
1389 { $$ = lookup_enum (copy_name ($2),
1390 expression_context_block); }
1391 | ENUM COMPLETE
1392 {
1393 mark_completion_tag (TYPE_CODE_ENUM, "", 0);
1394 $$ = NULL;
1395 }
1396 | ENUM name COMPLETE
1397 {
1398 mark_completion_tag (TYPE_CODE_ENUM, $2.ptr,
1399 $2.length);
1400 $$ = NULL;
1401 }
1402 | UNSIGNED type_name
1403 { $$ = lookup_unsigned_typename (parse_language (pstate),
1404 parse_gdbarch (pstate),
1405 TYPE_NAME($2.type)); }
1406 | UNSIGNED
1407 { $$ = lookup_unsigned_typename (parse_language (pstate),
1408 parse_gdbarch (pstate),
1409 "int"); }
1410 | SIGNED_KEYWORD type_name
1411 { $$ = lookup_signed_typename (parse_language (pstate),
1412 parse_gdbarch (pstate),
1413 TYPE_NAME($2.type)); }
1414 | SIGNED_KEYWORD
1415 { $$ = lookup_signed_typename (parse_language (pstate),
1416 parse_gdbarch (pstate),
1417 "int"); }
1418 /* It appears that this rule for templates is never
1419 reduced; template recognition happens by lookahead
1420 in the token processing code in yylex. */
1421 | TEMPLATE name '<' type '>'
1422 { $$ = lookup_template_type(copy_name($2), $4,
1423 expression_context_block);
1424 }
1425 | const_or_volatile_or_space_identifier_noopt typebase
1426 { $$ = follow_types ($2); }
1427 | typebase const_or_volatile_or_space_identifier_noopt
1428 { $$ = follow_types ($1); }
1429 ;
1430
1431 type_name: TYPENAME
1432 | INT_KEYWORD
1433 {
1434 $$.stoken.ptr = "int";
1435 $$.stoken.length = 3;
1436 $$.type = lookup_signed_typename (parse_language (pstate),
1437 parse_gdbarch (pstate),
1438 "int");
1439 }
1440 | LONG
1441 {
1442 $$.stoken.ptr = "long";
1443 $$.stoken.length = 4;
1444 $$.type = lookup_signed_typename (parse_language (pstate),
1445 parse_gdbarch (pstate),
1446 "long");
1447 }
1448 | SHORT
1449 {
1450 $$.stoken.ptr = "short";
1451 $$.stoken.length = 5;
1452 $$.type = lookup_signed_typename (parse_language (pstate),
1453 parse_gdbarch (pstate),
1454 "short");
1455 }
1456 ;
1457
1458 parameter_typelist:
1459 nonempty_typelist
1460 { check_parameter_typelist ($1); }
1461 | nonempty_typelist ',' DOTDOTDOT
1462 {
1463 VEC_safe_push (type_ptr, $1, NULL);
1464 check_parameter_typelist ($1);
1465 $$ = $1;
1466 }
1467 ;
1468
1469 nonempty_typelist
1470 : type
1471 {
1472 VEC (type_ptr) *typelist = NULL;
1473 VEC_safe_push (type_ptr, typelist, $1);
1474 $$ = typelist;
1475 }
1476 | nonempty_typelist ',' type
1477 {
1478 VEC_safe_push (type_ptr, $1, $3);
1479 $$ = $1;
1480 }
1481 ;
1482
1483 ptype : typebase
1484 | ptype abs_decl
1485 {
1486 push_type_stack ($2);
1487 $$ = follow_types ($1);
1488 }
1489 ;
1490
1491 conversion_type_id: typebase conversion_declarator
1492 { $$ = follow_types ($1); }
1493 ;
1494
1495 conversion_declarator: /* Nothing. */
1496 | ptr_operator conversion_declarator
1497 ;
1498
1499 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1500 | VOLATILE_KEYWORD CONST_KEYWORD
1501 ;
1502
1503 const_or_volatile_noopt: const_and_volatile
1504 { insert_type (tp_const);
1505 insert_type (tp_volatile);
1506 }
1507 | CONST_KEYWORD
1508 { insert_type (tp_const); }
1509 | VOLATILE_KEYWORD
1510 { insert_type (tp_volatile); }
1511 ;
1512
1513 oper: OPERATOR NEW
1514 { $$ = operator_stoken (" new"); }
1515 | OPERATOR DELETE
1516 { $$ = operator_stoken (" delete"); }
1517 | OPERATOR NEW '[' ']'
1518 { $$ = operator_stoken (" new[]"); }
1519 | OPERATOR DELETE '[' ']'
1520 { $$ = operator_stoken (" delete[]"); }
1521 | OPERATOR NEW OBJC_LBRAC ']'
1522 { $$ = operator_stoken (" new[]"); }
1523 | OPERATOR DELETE OBJC_LBRAC ']'
1524 { $$ = operator_stoken (" delete[]"); }
1525 | OPERATOR '+'
1526 { $$ = operator_stoken ("+"); }
1527 | OPERATOR '-'
1528 { $$ = operator_stoken ("-"); }
1529 | OPERATOR '*'
1530 { $$ = operator_stoken ("*"); }
1531 | OPERATOR '/'
1532 { $$ = operator_stoken ("/"); }
1533 | OPERATOR '%'
1534 { $$ = operator_stoken ("%"); }
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 ASSIGN_MODIFY
1552 { const char *op = " unknown";
1553 switch ($2)
1554 {
1555 case BINOP_RSH:
1556 op = ">>=";
1557 break;
1558 case BINOP_LSH:
1559 op = "<<=";
1560 break;
1561 case BINOP_ADD:
1562 op = "+=";
1563 break;
1564 case BINOP_SUB:
1565 op = "-=";
1566 break;
1567 case BINOP_MUL:
1568 op = "*=";
1569 break;
1570 case BINOP_DIV:
1571 op = "/=";
1572 break;
1573 case BINOP_REM:
1574 op = "%=";
1575 break;
1576 case BINOP_BITWISE_IOR:
1577 op = "|=";
1578 break;
1579 case BINOP_BITWISE_AND:
1580 op = "&=";
1581 break;
1582 case BINOP_BITWISE_XOR:
1583 op = "^=";
1584 break;
1585 default:
1586 break;
1587 }
1588
1589 $$ = operator_stoken (op);
1590 }
1591 | OPERATOR LSH
1592 { $$ = operator_stoken ("<<"); }
1593 | OPERATOR RSH
1594 { $$ = operator_stoken (">>"); }
1595 | OPERATOR EQUAL
1596 { $$ = operator_stoken ("=="); }
1597 | OPERATOR NOTEQUAL
1598 { $$ = operator_stoken ("!="); }
1599 | OPERATOR LEQ
1600 { $$ = operator_stoken ("<="); }
1601 | OPERATOR GEQ
1602 { $$ = operator_stoken (">="); }
1603 | OPERATOR ANDAND
1604 { $$ = operator_stoken ("&&"); }
1605 | OPERATOR OROR
1606 { $$ = operator_stoken ("||"); }
1607 | OPERATOR INCREMENT
1608 { $$ = operator_stoken ("++"); }
1609 | OPERATOR DECREMENT
1610 { $$ = operator_stoken ("--"); }
1611 | OPERATOR ','
1612 { $$ = operator_stoken (","); }
1613 | OPERATOR ARROW_STAR
1614 { $$ = operator_stoken ("->*"); }
1615 | OPERATOR ARROW
1616 { $$ = operator_stoken ("->"); }
1617 | OPERATOR '(' ')'
1618 { $$ = operator_stoken ("()"); }
1619 | OPERATOR '[' ']'
1620 { $$ = operator_stoken ("[]"); }
1621 | OPERATOR OBJC_LBRAC ']'
1622 { $$ = operator_stoken ("[]"); }
1623 | OPERATOR conversion_type_id
1624 { string_file buf;
1625
1626 c_print_type ($2, NULL, &buf, -1, 0,
1627 &type_print_raw_options);
1628
1629 /* This also needs canonicalization. */
1630 std::string canon
1631 = cp_canonicalize_string (buf.c_str ());
1632 if (canon.empty ())
1633 canon = std::move (buf.string ());
1634 $$ = operator_stoken ((" " + canon).c_str ());
1635 }
1636 ;
1637
1638
1639
1640 name : NAME { $$ = $1.stoken; }
1641 | BLOCKNAME { $$ = $1.stoken; }
1642 | TYPENAME { $$ = $1.stoken; }
1643 | NAME_OR_INT { $$ = $1.stoken; }
1644 | UNKNOWN_CPP_NAME { $$ = $1.stoken; }
1645 | oper { $$ = $1; }
1646 ;
1647
1648 name_not_typename : NAME
1649 | BLOCKNAME
1650 /* These would be useful if name_not_typename was useful, but it is just
1651 a fake for "variable", so these cause reduce/reduce conflicts because
1652 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1653 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1654 context where only a name could occur, this might be useful.
1655 | NAME_OR_INT
1656 */
1657 | oper
1658 {
1659 struct field_of_this_result is_a_field_of_this;
1660
1661 $$.stoken = $1;
1662 $$.sym = lookup_symbol ($1.ptr,
1663 expression_context_block,
1664 VAR_DOMAIN,
1665 &is_a_field_of_this);
1666 $$.is_a_field_of_this
1667 = is_a_field_of_this.type != NULL;
1668 }
1669 | UNKNOWN_CPP_NAME
1670 ;
1671
1672 %%
1673
1674 /* Like write_exp_string, but prepends a '~'. */
1675
1676 static void
1677 write_destructor_name (struct parser_state *par_state, struct stoken token)
1678 {
1679 char *copy = (char *) alloca (token.length + 1);
1680
1681 copy[0] = '~';
1682 memcpy (&copy[1], token.ptr, token.length);
1683
1684 token.ptr = copy;
1685 ++token.length;
1686
1687 write_exp_string (par_state, token);
1688 }
1689
1690 /* Returns a stoken of the operator name given by OP (which does not
1691 include the string "operator"). */
1692
1693 static struct stoken
1694 operator_stoken (const char *op)
1695 {
1696 struct stoken st = { NULL, 0 };
1697 char *buf;
1698
1699 st.length = CP_OPERATOR_LEN + strlen (op);
1700 buf = (char *) malloc (st.length + 1);
1701 strcpy (buf, CP_OPERATOR_STR);
1702 strcat (buf, op);
1703 st.ptr = buf;
1704
1705 /* The toplevel (c_parse) will free the memory allocated here. */
1706 make_cleanup (free, buf);
1707 return st;
1708 };
1709
1710 /* Return true if the type is aggregate-like. */
1711
1712 static int
1713 type_aggregate_p (struct type *type)
1714 {
1715 return (TYPE_CODE (type) == TYPE_CODE_STRUCT
1716 || TYPE_CODE (type) == TYPE_CODE_UNION
1717 || TYPE_CODE (type) == TYPE_CODE_NAMESPACE
1718 || (TYPE_CODE (type) == TYPE_CODE_ENUM
1719 && TYPE_DECLARED_CLASS (type)));
1720 }
1721
1722 /* Validate a parameter typelist. */
1723
1724 static void
1725 check_parameter_typelist (VEC (type_ptr) *params)
1726 {
1727 struct type *type;
1728 int ix;
1729
1730 for (ix = 0; VEC_iterate (type_ptr, params, ix, type); ++ix)
1731 {
1732 if (type != NULL && TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
1733 {
1734 if (ix == 0)
1735 {
1736 if (VEC_length (type_ptr, params) == 1)
1737 {
1738 /* Ok. */
1739 break;
1740 }
1741 VEC_free (type_ptr, params);
1742 error (_("parameter types following 'void'"));
1743 }
1744 else
1745 {
1746 VEC_free (type_ptr, params);
1747 error (_("'void' invalid as parameter type"));
1748 }
1749 }
1750 }
1751 }
1752
1753 /* Take care of parsing a number (anything that starts with a digit).
1754 Set yylval and return the token type; update lexptr.
1755 LEN is the number of characters in it. */
1756
1757 /*** Needs some error checking for the float case ***/
1758
1759 static int
1760 parse_number (struct parser_state *par_state,
1761 const char *buf, int len, int parsed_float, YYSTYPE *putithere)
1762 {
1763 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1764 here, and we do kind of silly things like cast to unsigned. */
1765 LONGEST n = 0;
1766 LONGEST prevn = 0;
1767 ULONGEST un;
1768
1769 int i = 0;
1770 int c;
1771 int base = input_radix;
1772 int unsigned_p = 0;
1773
1774 /* Number of "L" suffixes encountered. */
1775 int long_p = 0;
1776
1777 /* We have found a "L" or "U" suffix. */
1778 int found_suffix = 0;
1779
1780 ULONGEST high_bit;
1781 struct type *signed_type;
1782 struct type *unsigned_type;
1783 char *p;
1784
1785 p = (char *) alloca (len);
1786 memcpy (p, buf, len);
1787
1788 if (parsed_float)
1789 {
1790 /* Handle suffixes for decimal floating-point: "df", "dd" or "dl". */
1791 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1792 {
1793 putithere->typed_val_float.type
1794 = parse_type (par_state)->builtin_decfloat;
1795 len -= 2;
1796 }
1797 else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1798 {
1799 putithere->typed_val_float.type
1800 = parse_type (par_state)->builtin_decdouble;
1801 len -= 2;
1802 }
1803 else if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1804 {
1805 putithere->typed_val_float.type
1806 = parse_type (par_state)->builtin_declong;
1807 len -= 2;
1808 }
1809 /* Handle suffixes: 'f' for float, 'l' for long double. */
1810 else if (len >= 1 && TOLOWER (p[len - 1]) == 'f')
1811 {
1812 putithere->typed_val_float.type
1813 = parse_type (par_state)->builtin_float;
1814 len -= 1;
1815 }
1816 else if (len >= 1 && TOLOWER (p[len - 1]) == 'l')
1817 {
1818 putithere->typed_val_float.type
1819 = parse_type (par_state)->builtin_long_double;
1820 len -= 1;
1821 }
1822 /* Default type for floating-point literals is double. */
1823 else
1824 {
1825 putithere->typed_val_float.type
1826 = parse_type (par_state)->builtin_double;
1827 }
1828
1829 if (!parse_float (p, len,
1830 putithere->typed_val_float.type,
1831 putithere->typed_val_float.val))
1832 return ERROR;
1833 return FLOAT;
1834 }
1835
1836 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1837 if (p[0] == '0' && len > 1)
1838 switch (p[1])
1839 {
1840 case 'x':
1841 case 'X':
1842 if (len >= 3)
1843 {
1844 p += 2;
1845 base = 16;
1846 len -= 2;
1847 }
1848 break;
1849
1850 case 'b':
1851 case 'B':
1852 if (len >= 3)
1853 {
1854 p += 2;
1855 base = 2;
1856 len -= 2;
1857 }
1858 break;
1859
1860 case 't':
1861 case 'T':
1862 case 'd':
1863 case 'D':
1864 if (len >= 3)
1865 {
1866 p += 2;
1867 base = 10;
1868 len -= 2;
1869 }
1870 break;
1871
1872 default:
1873 base = 8;
1874 break;
1875 }
1876
1877 while (len-- > 0)
1878 {
1879 c = *p++;
1880 if (c >= 'A' && c <= 'Z')
1881 c += 'a' - 'A';
1882 if (c != 'l' && c != 'u')
1883 n *= base;
1884 if (c >= '0' && c <= '9')
1885 {
1886 if (found_suffix)
1887 return ERROR;
1888 n += i = c - '0';
1889 }
1890 else
1891 {
1892 if (base > 10 && c >= 'a' && c <= 'f')
1893 {
1894 if (found_suffix)
1895 return ERROR;
1896 n += i = c - 'a' + 10;
1897 }
1898 else if (c == 'l')
1899 {
1900 ++long_p;
1901 found_suffix = 1;
1902 }
1903 else if (c == 'u')
1904 {
1905 unsigned_p = 1;
1906 found_suffix = 1;
1907 }
1908 else
1909 return ERROR; /* Char not a digit */
1910 }
1911 if (i >= base)
1912 return ERROR; /* Invalid digit in this base */
1913
1914 /* Portably test for overflow (only works for nonzero values, so make
1915 a second check for zero). FIXME: Can't we just make n and prevn
1916 unsigned and avoid this? */
1917 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1918 unsigned_p = 1; /* Try something unsigned */
1919
1920 /* Portably test for unsigned overflow.
1921 FIXME: This check is wrong; for example it doesn't find overflow
1922 on 0x123456789 when LONGEST is 32 bits. */
1923 if (c != 'l' && c != 'u' && n != 0)
1924 {
1925 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1926 error (_("Numeric constant too large."));
1927 }
1928 prevn = n;
1929 }
1930
1931 /* An integer constant is an int, a long, or a long long. An L
1932 suffix forces it to be long; an LL suffix forces it to be long
1933 long. If not forced to a larger size, it gets the first type of
1934 the above that it fits in. To figure out whether it fits, we
1935 shift it right and see whether anything remains. Note that we
1936 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1937 operation, because many compilers will warn about such a shift
1938 (which always produces a zero result). Sometimes gdbarch_int_bit
1939 or gdbarch_long_bit will be that big, sometimes not. To deal with
1940 the case where it is we just always shift the value more than
1941 once, with fewer bits each time. */
1942
1943 un = (ULONGEST)n >> 2;
1944 if (long_p == 0
1945 && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
1946 {
1947 high_bit
1948 = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
1949
1950 /* A large decimal (not hex or octal) constant (between INT_MAX
1951 and UINT_MAX) is a long or unsigned long, according to ANSI,
1952 never an unsigned int, but this code treats it as unsigned
1953 int. This probably should be fixed. GCC gives a warning on
1954 such constants. */
1955
1956 unsigned_type = parse_type (par_state)->builtin_unsigned_int;
1957 signed_type = parse_type (par_state)->builtin_int;
1958 }
1959 else if (long_p <= 1
1960 && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
1961 {
1962 high_bit
1963 = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
1964 unsigned_type = parse_type (par_state)->builtin_unsigned_long;
1965 signed_type = parse_type (par_state)->builtin_long;
1966 }
1967 else
1968 {
1969 int shift;
1970 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1971 < gdbarch_long_long_bit (parse_gdbarch (par_state)))
1972 /* A long long does not fit in a LONGEST. */
1973 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1974 else
1975 shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
1976 high_bit = (ULONGEST) 1 << shift;
1977 unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
1978 signed_type = parse_type (par_state)->builtin_long_long;
1979 }
1980
1981 putithere->typed_val_int.val = n;
1982
1983 /* If the high bit of the worked out type is set then this number
1984 has to be unsigned. */
1985
1986 if (unsigned_p || (n & high_bit))
1987 {
1988 putithere->typed_val_int.type = unsigned_type;
1989 }
1990 else
1991 {
1992 putithere->typed_val_int.type = signed_type;
1993 }
1994
1995 return INT;
1996 }
1997
1998 /* Temporary obstack used for holding strings. */
1999 static struct obstack tempbuf;
2000 static int tempbuf_init;
2001
2002 /* Parse a C escape sequence. The initial backslash of the sequence
2003 is at (*PTR)[-1]. *PTR will be updated to point to just after the
2004 last character of the sequence. If OUTPUT is not NULL, the
2005 translated form of the escape sequence will be written there. If
2006 OUTPUT is NULL, no output is written and the call will only affect
2007 *PTR. If an escape sequence is expressed in target bytes, then the
2008 entire sequence will simply be copied to OUTPUT. Return 1 if any
2009 character was emitted, 0 otherwise. */
2010
2011 int
2012 c_parse_escape (const char **ptr, struct obstack *output)
2013 {
2014 const char *tokptr = *ptr;
2015 int result = 1;
2016
2017 /* Some escape sequences undergo character set conversion. Those we
2018 translate here. */
2019 switch (*tokptr)
2020 {
2021 /* Hex escapes do not undergo character set conversion, so keep
2022 the escape sequence for later. */
2023 case 'x':
2024 if (output)
2025 obstack_grow_str (output, "\\x");
2026 ++tokptr;
2027 if (!ISXDIGIT (*tokptr))
2028 error (_("\\x escape without a following hex digit"));
2029 while (ISXDIGIT (*tokptr))
2030 {
2031 if (output)
2032 obstack_1grow (output, *tokptr);
2033 ++tokptr;
2034 }
2035 break;
2036
2037 /* Octal escapes do not undergo character set conversion, so
2038 keep the escape sequence for later. */
2039 case '0':
2040 case '1':
2041 case '2':
2042 case '3':
2043 case '4':
2044 case '5':
2045 case '6':
2046 case '7':
2047 {
2048 int i;
2049 if (output)
2050 obstack_grow_str (output, "\\");
2051 for (i = 0;
2052 i < 3 && ISDIGIT (*tokptr) && *tokptr != '8' && *tokptr != '9';
2053 ++i)
2054 {
2055 if (output)
2056 obstack_1grow (output, *tokptr);
2057 ++tokptr;
2058 }
2059 }
2060 break;
2061
2062 /* We handle UCNs later. We could handle them here, but that
2063 would mean a spurious error in the case where the UCN could
2064 be converted to the target charset but not the host
2065 charset. */
2066 case 'u':
2067 case 'U':
2068 {
2069 char c = *tokptr;
2070 int i, len = c == 'U' ? 8 : 4;
2071 if (output)
2072 {
2073 obstack_1grow (output, '\\');
2074 obstack_1grow (output, *tokptr);
2075 }
2076 ++tokptr;
2077 if (!ISXDIGIT (*tokptr))
2078 error (_("\\%c escape without a following hex digit"), c);
2079 for (i = 0; i < len && ISXDIGIT (*tokptr); ++i)
2080 {
2081 if (output)
2082 obstack_1grow (output, *tokptr);
2083 ++tokptr;
2084 }
2085 }
2086 break;
2087
2088 /* We must pass backslash through so that it does not
2089 cause quoting during the second expansion. */
2090 case '\\':
2091 if (output)
2092 obstack_grow_str (output, "\\\\");
2093 ++tokptr;
2094 break;
2095
2096 /* Escapes which undergo conversion. */
2097 case 'a':
2098 if (output)
2099 obstack_1grow (output, '\a');
2100 ++tokptr;
2101 break;
2102 case 'b':
2103 if (output)
2104 obstack_1grow (output, '\b');
2105 ++tokptr;
2106 break;
2107 case 'f':
2108 if (output)
2109 obstack_1grow (output, '\f');
2110 ++tokptr;
2111 break;
2112 case 'n':
2113 if (output)
2114 obstack_1grow (output, '\n');
2115 ++tokptr;
2116 break;
2117 case 'r':
2118 if (output)
2119 obstack_1grow (output, '\r');
2120 ++tokptr;
2121 break;
2122 case 't':
2123 if (output)
2124 obstack_1grow (output, '\t');
2125 ++tokptr;
2126 break;
2127 case 'v':
2128 if (output)
2129 obstack_1grow (output, '\v');
2130 ++tokptr;
2131 break;
2132
2133 /* GCC extension. */
2134 case 'e':
2135 if (output)
2136 obstack_1grow (output, HOST_ESCAPE_CHAR);
2137 ++tokptr;
2138 break;
2139
2140 /* Backslash-newline expands to nothing at all. */
2141 case '\n':
2142 ++tokptr;
2143 result = 0;
2144 break;
2145
2146 /* A few escapes just expand to the character itself. */
2147 case '\'':
2148 case '\"':
2149 case '?':
2150 /* GCC extensions. */
2151 case '(':
2152 case '{':
2153 case '[':
2154 case '%':
2155 /* Unrecognized escapes turn into the character itself. */
2156 default:
2157 if (output)
2158 obstack_1grow (output, *tokptr);
2159 ++tokptr;
2160 break;
2161 }
2162 *ptr = tokptr;
2163 return result;
2164 }
2165
2166 /* Parse a string or character literal from TOKPTR. The string or
2167 character may be wide or unicode. *OUTPTR is set to just after the
2168 end of the literal in the input string. The resulting token is
2169 stored in VALUE. This returns a token value, either STRING or
2170 CHAR, depending on what was parsed. *HOST_CHARS is set to the
2171 number of host characters in the literal. */
2172
2173 static int
2174 parse_string_or_char (const char *tokptr, const char **outptr,
2175 struct typed_stoken *value, int *host_chars)
2176 {
2177 int quote;
2178 c_string_type type;
2179 int is_objc = 0;
2180
2181 /* Build the gdb internal form of the input string in tempbuf. Note
2182 that the buffer is null byte terminated *only* for the
2183 convenience of debugging gdb itself and printing the buffer
2184 contents when the buffer contains no embedded nulls. Gdb does
2185 not depend upon the buffer being null byte terminated, it uses
2186 the length string instead. This allows gdb to handle C strings
2187 (as well as strings in other languages) with embedded null
2188 bytes */
2189
2190 if (!tempbuf_init)
2191 tempbuf_init = 1;
2192 else
2193 obstack_free (&tempbuf, NULL);
2194 obstack_init (&tempbuf);
2195
2196 /* Record the string type. */
2197 if (*tokptr == 'L')
2198 {
2199 type = C_WIDE_STRING;
2200 ++tokptr;
2201 }
2202 else if (*tokptr == 'u')
2203 {
2204 type = C_STRING_16;
2205 ++tokptr;
2206 }
2207 else if (*tokptr == 'U')
2208 {
2209 type = C_STRING_32;
2210 ++tokptr;
2211 }
2212 else if (*tokptr == '@')
2213 {
2214 /* An Objective C string. */
2215 is_objc = 1;
2216 type = C_STRING;
2217 ++tokptr;
2218 }
2219 else
2220 type = C_STRING;
2221
2222 /* Skip the quote. */
2223 quote = *tokptr;
2224 if (quote == '\'')
2225 type |= C_CHAR;
2226 ++tokptr;
2227
2228 *host_chars = 0;
2229
2230 while (*tokptr)
2231 {
2232 char c = *tokptr;
2233 if (c == '\\')
2234 {
2235 ++tokptr;
2236 *host_chars += c_parse_escape (&tokptr, &tempbuf);
2237 }
2238 else if (c == quote)
2239 break;
2240 else
2241 {
2242 obstack_1grow (&tempbuf, c);
2243 ++tokptr;
2244 /* FIXME: this does the wrong thing with multi-byte host
2245 characters. We could use mbrlen here, but that would
2246 make "set host-charset" a bit less useful. */
2247 ++*host_chars;
2248 }
2249 }
2250
2251 if (*tokptr != quote)
2252 {
2253 if (quote == '"')
2254 error (_("Unterminated string in expression."));
2255 else
2256 error (_("Unmatched single quote."));
2257 }
2258 ++tokptr;
2259
2260 value->type = type;
2261 value->ptr = (char *) obstack_base (&tempbuf);
2262 value->length = obstack_object_size (&tempbuf);
2263
2264 *outptr = tokptr;
2265
2266 return quote == '"' ? (is_objc ? NSSTRING : STRING) : CHAR;
2267 }
2268
2269 /* This is used to associate some attributes with a token. */
2270
2271 enum token_flag
2272 {
2273 /* If this bit is set, the token is C++-only. */
2274
2275 FLAG_CXX = 1,
2276
2277 /* If this bit is set, the token is conditional: if there is a
2278 symbol of the same name, then the token is a symbol; otherwise,
2279 the token is a keyword. */
2280
2281 FLAG_SHADOW = 2
2282 };
2283 DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);
2284
2285 struct token
2286 {
2287 const char *oper;
2288 int token;
2289 enum exp_opcode opcode;
2290 token_flags flags;
2291 };
2292
2293 static const struct token tokentab3[] =
2294 {
2295 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
2296 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
2297 {"->*", ARROW_STAR, BINOP_END, FLAG_CXX},
2298 {"...", DOTDOTDOT, BINOP_END, 0}
2299 };
2300
2301 static const struct token tokentab2[] =
2302 {
2303 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
2304 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
2305 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
2306 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
2307 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
2308 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
2309 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
2310 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
2311 {"++", INCREMENT, BINOP_END, 0},
2312 {"--", DECREMENT, BINOP_END, 0},
2313 {"->", ARROW, BINOP_END, 0},
2314 {"&&", ANDAND, BINOP_END, 0},
2315 {"||", OROR, BINOP_END, 0},
2316 /* "::" is *not* only C++: gdb overrides its meaning in several
2317 different ways, e.g., 'filename'::func, function::variable. */
2318 {"::", COLONCOLON, BINOP_END, 0},
2319 {"<<", LSH, BINOP_END, 0},
2320 {">>", RSH, BINOP_END, 0},
2321 {"==", EQUAL, BINOP_END, 0},
2322 {"!=", NOTEQUAL, BINOP_END, 0},
2323 {"<=", LEQ, BINOP_END, 0},
2324 {">=", GEQ, BINOP_END, 0},
2325 {".*", DOT_STAR, BINOP_END, FLAG_CXX}
2326 };
2327
2328 /* Identifier-like tokens. */
2329 static const struct token ident_tokens[] =
2330 {
2331 {"unsigned", UNSIGNED, OP_NULL, 0},
2332 {"template", TEMPLATE, OP_NULL, FLAG_CXX},
2333 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
2334 {"struct", STRUCT, OP_NULL, 0},
2335 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
2336 {"sizeof", SIZEOF, OP_NULL, 0},
2337 {"_Alignof", ALIGNOF, OP_NULL, 0},
2338 {"alignof", ALIGNOF, OP_NULL, FLAG_CXX},
2339 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
2340 {"false", FALSEKEYWORD, OP_NULL, FLAG_CXX},
2341 {"class", CLASS, OP_NULL, FLAG_CXX},
2342 {"union", UNION, OP_NULL, 0},
2343 {"short", SHORT, OP_NULL, 0},
2344 {"const", CONST_KEYWORD, OP_NULL, 0},
2345 {"enum", ENUM, OP_NULL, 0},
2346 {"long", LONG, OP_NULL, 0},
2347 {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
2348 {"int", INT_KEYWORD, OP_NULL, 0},
2349 {"new", NEW, OP_NULL, FLAG_CXX},
2350 {"delete", DELETE, OP_NULL, FLAG_CXX},
2351 {"operator", OPERATOR, OP_NULL, FLAG_CXX},
2352
2353 {"and", ANDAND, BINOP_END, FLAG_CXX},
2354 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, FLAG_CXX},
2355 {"bitand", '&', OP_NULL, FLAG_CXX},
2356 {"bitor", '|', OP_NULL, FLAG_CXX},
2357 {"compl", '~', OP_NULL, FLAG_CXX},
2358 {"not", '!', OP_NULL, FLAG_CXX},
2359 {"not_eq", NOTEQUAL, BINOP_END, FLAG_CXX},
2360 {"or", OROR, BINOP_END, FLAG_CXX},
2361 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, FLAG_CXX},
2362 {"xor", '^', OP_NULL, FLAG_CXX},
2363 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, FLAG_CXX},
2364
2365 {"const_cast", CONST_CAST, OP_NULL, FLAG_CXX },
2366 {"dynamic_cast", DYNAMIC_CAST, OP_NULL, FLAG_CXX },
2367 {"static_cast", STATIC_CAST, OP_NULL, FLAG_CXX },
2368 {"reinterpret_cast", REINTERPRET_CAST, OP_NULL, FLAG_CXX },
2369
2370 {"__typeof__", TYPEOF, OP_TYPEOF, 0 },
2371 {"__typeof", TYPEOF, OP_TYPEOF, 0 },
2372 {"typeof", TYPEOF, OP_TYPEOF, FLAG_SHADOW },
2373 {"__decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX },
2374 {"decltype", DECLTYPE, OP_DECLTYPE, FLAG_CXX | FLAG_SHADOW },
2375
2376 {"typeid", TYPEID, OP_TYPEID, FLAG_CXX}
2377 };
2378
2379 /* When we find that lexptr (the global var defined in parse.c) is
2380 pointing at a macro invocation, we expand the invocation, and call
2381 scan_macro_expansion to save the old lexptr here and point lexptr
2382 into the expanded text. When we reach the end of that, we call
2383 end_macro_expansion to pop back to the value we saved here. The
2384 macro expansion code promises to return only fully-expanded text,
2385 so we don't need to "push" more than one level.
2386
2387 This is disgusting, of course. It would be cleaner to do all macro
2388 expansion beforehand, and then hand that to lexptr. But we don't
2389 really know where the expression ends. Remember, in a command like
2390
2391 (gdb) break *ADDRESS if CONDITION
2392
2393 we evaluate ADDRESS in the scope of the current frame, but we
2394 evaluate CONDITION in the scope of the breakpoint's location. So
2395 it's simply wrong to try to macro-expand the whole thing at once. */
2396 static const char *macro_original_text;
2397
2398 /* We save all intermediate macro expansions on this obstack for the
2399 duration of a single parse. The expansion text may sometimes have
2400 to live past the end of the expansion, due to yacc lookahead.
2401 Rather than try to be clever about saving the data for a single
2402 token, we simply keep it all and delete it after parsing has
2403 completed. */
2404 static struct obstack expansion_obstack;
2405
2406 static void
2407 scan_macro_expansion (char *expansion)
2408 {
2409 char *copy;
2410
2411 /* We'd better not be trying to push the stack twice. */
2412 gdb_assert (! macro_original_text);
2413
2414 /* Copy to the obstack, and then free the intermediate
2415 expansion. */
2416 copy = (char *) obstack_copy0 (&expansion_obstack, expansion,
2417 strlen (expansion));
2418 xfree (expansion);
2419
2420 /* Save the old lexptr value, so we can return to it when we're done
2421 parsing the expanded text. */
2422 macro_original_text = lexptr;
2423 lexptr = copy;
2424 }
2425
2426 static int
2427 scanning_macro_expansion (void)
2428 {
2429 return macro_original_text != 0;
2430 }
2431
2432 static void
2433 finished_macro_expansion (void)
2434 {
2435 /* There'd better be something to pop back to. */
2436 gdb_assert (macro_original_text);
2437
2438 /* Pop back to the original text. */
2439 lexptr = macro_original_text;
2440 macro_original_text = 0;
2441 }
2442
2443 static void
2444 scan_macro_cleanup (void *dummy)
2445 {
2446 if (macro_original_text)
2447 finished_macro_expansion ();
2448
2449 obstack_free (&expansion_obstack, NULL);
2450 }
2451
2452 /* Return true iff the token represents a C++ cast operator. */
2453
2454 static int
2455 is_cast_operator (const char *token, int len)
2456 {
2457 return (! strncmp (token, "dynamic_cast", len)
2458 || ! strncmp (token, "static_cast", len)
2459 || ! strncmp (token, "reinterpret_cast", len)
2460 || ! strncmp (token, "const_cast", len));
2461 }
2462
2463 /* The scope used for macro expansion. */
2464 static struct macro_scope *expression_macro_scope;
2465
2466 /* This is set if a NAME token appeared at the very end of the input
2467 string, with no whitespace separating the name from the EOF. This
2468 is used only when parsing to do field name completion. */
2469 static int saw_name_at_eof;
2470
2471 /* This is set if the previously-returned token was a structure
2472 operator -- either '.' or ARROW. */
2473 static bool last_was_structop;
2474
2475 /* Read one token, getting characters through lexptr. */
2476
2477 static int
2478 lex_one_token (struct parser_state *par_state, bool *is_quoted_name)
2479 {
2480 int c;
2481 int namelen;
2482 unsigned int i;
2483 const char *tokstart;
2484 bool saw_structop = last_was_structop;
2485 char *copy;
2486
2487 last_was_structop = false;
2488 *is_quoted_name = false;
2489
2490 retry:
2491
2492 /* Check if this is a macro invocation that we need to expand. */
2493 if (! scanning_macro_expansion ())
2494 {
2495 char *expanded = macro_expand_next (&lexptr,
2496 standard_macro_lookup,
2497 expression_macro_scope);
2498
2499 if (expanded)
2500 scan_macro_expansion (expanded);
2501 }
2502
2503 prev_lexptr = lexptr;
2504
2505 tokstart = lexptr;
2506 /* See if it is a special token of length 3. */
2507 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2508 if (strncmp (tokstart, tokentab3[i].oper, 3) == 0)
2509 {
2510 if ((tokentab3[i].flags & FLAG_CXX) != 0
2511 && parse_language (par_state)->la_language != language_cplus)
2512 break;
2513
2514 lexptr += 3;
2515 yylval.opcode = tokentab3[i].opcode;
2516 return tokentab3[i].token;
2517 }
2518
2519 /* See if it is a special token of length 2. */
2520 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2521 if (strncmp (tokstart, tokentab2[i].oper, 2) == 0)
2522 {
2523 if ((tokentab2[i].flags & FLAG_CXX) != 0
2524 && parse_language (par_state)->la_language != language_cplus)
2525 break;
2526
2527 lexptr += 2;
2528 yylval.opcode = tokentab2[i].opcode;
2529 if (tokentab2[i].token == ARROW)
2530 last_was_structop = 1;
2531 return tokentab2[i].token;
2532 }
2533
2534 switch (c = *tokstart)
2535 {
2536 case 0:
2537 /* If we were just scanning the result of a macro expansion,
2538 then we need to resume scanning the original text.
2539 If we're parsing for field name completion, and the previous
2540 token allows such completion, return a COMPLETE token.
2541 Otherwise, we were already scanning the original text, and
2542 we're really done. */
2543 if (scanning_macro_expansion ())
2544 {
2545 finished_macro_expansion ();
2546 goto retry;
2547 }
2548 else if (saw_name_at_eof)
2549 {
2550 saw_name_at_eof = 0;
2551 return COMPLETE;
2552 }
2553 else if (parse_completion && saw_structop)
2554 return COMPLETE;
2555 else
2556 return 0;
2557
2558 case ' ':
2559 case '\t':
2560 case '\n':
2561 lexptr++;
2562 goto retry;
2563
2564 case '[':
2565 case '(':
2566 paren_depth++;
2567 lexptr++;
2568 if (parse_language (par_state)->la_language == language_objc
2569 && c == '[')
2570 return OBJC_LBRAC;
2571 return c;
2572
2573 case ']':
2574 case ')':
2575 if (paren_depth == 0)
2576 return 0;
2577 paren_depth--;
2578 lexptr++;
2579 return c;
2580
2581 case ',':
2582 if (comma_terminates
2583 && paren_depth == 0
2584 && ! scanning_macro_expansion ())
2585 return 0;
2586 lexptr++;
2587 return c;
2588
2589 case '.':
2590 /* Might be a floating point number. */
2591 if (lexptr[1] < '0' || lexptr[1] > '9')
2592 {
2593 last_was_structop = true;
2594 goto symbol; /* Nope, must be a symbol. */
2595 }
2596 /* FALL THRU. */
2597
2598 case '0':
2599 case '1':
2600 case '2':
2601 case '3':
2602 case '4':
2603 case '5':
2604 case '6':
2605 case '7':
2606 case '8':
2607 case '9':
2608 {
2609 /* It's a number. */
2610 int got_dot = 0, got_e = 0, toktype;
2611 const char *p = tokstart;
2612 int hex = input_radix > 10;
2613
2614 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2615 {
2616 p += 2;
2617 hex = 1;
2618 }
2619 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2620 {
2621 p += 2;
2622 hex = 0;
2623 }
2624
2625 for (;; ++p)
2626 {
2627 /* This test includes !hex because 'e' is a valid hex digit
2628 and thus does not indicate a floating point number when
2629 the radix is hex. */
2630 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2631 got_dot = got_e = 1;
2632 /* This test does not include !hex, because a '.' always indicates
2633 a decimal floating point number regardless of the radix. */
2634 else if (!got_dot && *p == '.')
2635 got_dot = 1;
2636 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2637 && (*p == '-' || *p == '+'))
2638 /* This is the sign of the exponent, not the end of the
2639 number. */
2640 continue;
2641 /* We will take any letters or digits. parse_number will
2642 complain if past the radix, or if L or U are not final. */
2643 else if ((*p < '0' || *p > '9')
2644 && ((*p < 'a' || *p > 'z')
2645 && (*p < 'A' || *p > 'Z')))
2646 break;
2647 }
2648 toktype = parse_number (par_state, tokstart, p - tokstart,
2649 got_dot|got_e, &yylval);
2650 if (toktype == ERROR)
2651 {
2652 char *err_copy = (char *) alloca (p - tokstart + 1);
2653
2654 memcpy (err_copy, tokstart, p - tokstart);
2655 err_copy[p - tokstart] = 0;
2656 error (_("Invalid number \"%s\"."), err_copy);
2657 }
2658 lexptr = p;
2659 return toktype;
2660 }
2661
2662 case '@':
2663 {
2664 const char *p = &tokstart[1];
2665 size_t len = strlen ("entry");
2666
2667 if (parse_language (par_state)->la_language == language_objc)
2668 {
2669 size_t len = strlen ("selector");
2670
2671 if (strncmp (p, "selector", len) == 0
2672 && (p[len] == '\0' || ISSPACE (p[len])))
2673 {
2674 lexptr = p + len;
2675 return SELECTOR;
2676 }
2677 else if (*p == '"')
2678 goto parse_string;
2679 }
2680
2681 while (ISSPACE (*p))
2682 p++;
2683 if (strncmp (p, "entry", len) == 0 && !c_ident_is_alnum (p[len])
2684 && p[len] != '_')
2685 {
2686 lexptr = &p[len];
2687 return ENTRY;
2688 }
2689 }
2690 /* FALLTHRU */
2691 case '+':
2692 case '-':
2693 case '*':
2694 case '/':
2695 case '%':
2696 case '|':
2697 case '&':
2698 case '^':
2699 case '~':
2700 case '!':
2701 case '<':
2702 case '>':
2703 case '?':
2704 case ':':
2705 case '=':
2706 case '{':
2707 case '}':
2708 symbol:
2709 lexptr++;
2710 return c;
2711
2712 case 'L':
2713 case 'u':
2714 case 'U':
2715 if (tokstart[1] != '"' && tokstart[1] != '\'')
2716 break;
2717 /* Fall through. */
2718 case '\'':
2719 case '"':
2720
2721 parse_string:
2722 {
2723 int host_len;
2724 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2725 &host_len);
2726 if (result == CHAR)
2727 {
2728 if (host_len == 0)
2729 error (_("Empty character constant."));
2730 else if (host_len > 2 && c == '\'')
2731 {
2732 ++tokstart;
2733 namelen = lexptr - tokstart - 1;
2734 *is_quoted_name = true;
2735
2736 goto tryname;
2737 }
2738 else if (host_len > 1)
2739 error (_("Invalid character constant."));
2740 }
2741 return result;
2742 }
2743 }
2744
2745 if (!(c == '_' || c == '$' || c_ident_is_alpha (c)))
2746 /* We must have come across a bad character (e.g. ';'). */
2747 error (_("Invalid character '%c' in expression."), c);
2748
2749 /* It's a name. See how long it is. */
2750 namelen = 0;
2751 for (c = tokstart[namelen];
2752 (c == '_' || c == '$' || c_ident_is_alnum (c) || c == '<');)
2753 {
2754 /* Template parameter lists are part of the name.
2755 FIXME: This mishandles `print $a<4&&$a>3'. */
2756
2757 if (c == '<')
2758 {
2759 if (! is_cast_operator (tokstart, namelen))
2760 {
2761 /* Scan ahead to get rest of the template specification. Note
2762 that we look ahead only when the '<' adjoins non-whitespace
2763 characters; for comparison expressions, e.g. "a < b > c",
2764 there must be spaces before the '<', etc. */
2765 const char *p = find_template_name_end (tokstart + namelen);
2766
2767 if (p)
2768 namelen = p - tokstart;
2769 }
2770 break;
2771 }
2772 c = tokstart[++namelen];
2773 }
2774
2775 /* The token "if" terminates the expression and is NOT removed from
2776 the input stream. It doesn't count if it appears in the
2777 expansion of a macro. */
2778 if (namelen == 2
2779 && tokstart[0] == 'i'
2780 && tokstart[1] == 'f'
2781 && ! scanning_macro_expansion ())
2782 {
2783 return 0;
2784 }
2785
2786 /* For the same reason (breakpoint conditions), "thread N"
2787 terminates the expression. "thread" could be an identifier, but
2788 an identifier is never followed by a number without intervening
2789 punctuation. "task" is similar. Handle abbreviations of these,
2790 similarly to breakpoint.c:find_condition_and_thread. */
2791 if (namelen >= 1
2792 && (strncmp (tokstart, "thread", namelen) == 0
2793 || strncmp (tokstart, "task", namelen) == 0)
2794 && (tokstart[namelen] == ' ' || tokstart[namelen] == '\t')
2795 && ! scanning_macro_expansion ())
2796 {
2797 const char *p = tokstart + namelen + 1;
2798
2799 while (*p == ' ' || *p == '\t')
2800 p++;
2801 if (*p >= '0' && *p <= '9')
2802 return 0;
2803 }
2804
2805 lexptr += namelen;
2806
2807 tryname:
2808
2809 yylval.sval.ptr = tokstart;
2810 yylval.sval.length = namelen;
2811
2812 /* Catch specific keywords. */
2813 copy = copy_name (yylval.sval);
2814 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2815 if (strcmp (copy, ident_tokens[i].oper) == 0)
2816 {
2817 if ((ident_tokens[i].flags & FLAG_CXX) != 0
2818 && parse_language (par_state)->la_language != language_cplus)
2819 break;
2820
2821 if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
2822 {
2823 struct field_of_this_result is_a_field_of_this;
2824
2825 if (lookup_symbol (copy, expression_context_block,
2826 VAR_DOMAIN,
2827 (parse_language (par_state)->la_language
2828 == language_cplus ? &is_a_field_of_this
2829 : NULL)).symbol
2830 != NULL)
2831 {
2832 /* The keyword is shadowed. */
2833 break;
2834 }
2835 }
2836
2837 /* It is ok to always set this, even though we don't always
2838 strictly need to. */
2839 yylval.opcode = ident_tokens[i].opcode;
2840 return ident_tokens[i].token;
2841 }
2842
2843 if (*tokstart == '$')
2844 return VARIABLE;
2845
2846 if (parse_completion && *lexptr == '\0')
2847 saw_name_at_eof = 1;
2848
2849 yylval.ssym.stoken = yylval.sval;
2850 yylval.ssym.sym.symbol = NULL;
2851 yylval.ssym.sym.block = NULL;
2852 yylval.ssym.is_a_field_of_this = 0;
2853 return NAME;
2854 }
2855
2856 /* An object of this type is pushed on a FIFO by the "outer" lexer. */
2857 struct token_and_value
2858 {
2859 int token;
2860 YYSTYPE value;
2861 };
2862
2863 /* A FIFO of tokens that have been read but not yet returned to the
2864 parser. */
2865 static std::vector<token_and_value> token_fifo;
2866
2867 /* Non-zero if the lexer should return tokens from the FIFO. */
2868 static int popping;
2869
2870 /* Temporary storage for c_lex; this holds symbol names as they are
2871 built up. */
2872 auto_obstack name_obstack;
2873
2874 /* Classify a NAME token. The contents of the token are in `yylval'.
2875 Updates yylval and returns the new token type. BLOCK is the block
2876 in which lookups start; this can be NULL to mean the global scope.
2877 IS_QUOTED_NAME is non-zero if the name token was originally quoted
2878 in single quotes. IS_AFTER_STRUCTOP is true if this name follows
2879 a structure operator -- either '.' or ARROW */
2880
2881 static int
2882 classify_name (struct parser_state *par_state, const struct block *block,
2883 bool is_quoted_name, bool is_after_structop)
2884 {
2885 struct block_symbol bsym;
2886 char *copy;
2887 struct field_of_this_result is_a_field_of_this;
2888
2889 copy = copy_name (yylval.sval);
2890
2891 /* Initialize this in case we *don't* use it in this call; that way
2892 we can refer to it unconditionally below. */
2893 memset (&is_a_field_of_this, 0, sizeof (is_a_field_of_this));
2894
2895 bsym = lookup_symbol (copy, block, VAR_DOMAIN,
2896 parse_language (par_state)->la_name_of_this
2897 ? &is_a_field_of_this : NULL);
2898
2899 if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_BLOCK)
2900 {
2901 yylval.ssym.sym = bsym;
2902 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2903 return BLOCKNAME;
2904 }
2905 else if (!bsym.symbol)
2906 {
2907 /* If we found a field of 'this', we might have erroneously
2908 found a constructor where we wanted a type name. Handle this
2909 case by noticing that we found a constructor and then look up
2910 the type tag instead. */
2911 if (is_a_field_of_this.type != NULL
2912 && is_a_field_of_this.fn_field != NULL
2913 && TYPE_FN_FIELD_CONSTRUCTOR (is_a_field_of_this.fn_field->fn_fields,
2914 0))
2915 {
2916 struct field_of_this_result inner_is_a_field_of_this;
2917
2918 bsym = lookup_symbol (copy, block, STRUCT_DOMAIN,
2919 &inner_is_a_field_of_this);
2920 if (bsym.symbol != NULL)
2921 {
2922 yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
2923 return TYPENAME;
2924 }
2925 }
2926
2927 /* If we found a field on the "this" object, or we are looking
2928 up a field on a struct, then we want to prefer it over a
2929 filename. However, if the name was quoted, then it is better
2930 to check for a filename or a block, since this is the only
2931 way the user has of requiring the extension to be used. */
2932 if ((is_a_field_of_this.type == NULL && !is_after_structop)
2933 || is_quoted_name)
2934 {
2935 /* See if it's a file name. */
2936 struct symtab *symtab;
2937
2938 symtab = lookup_symtab (copy);
2939 if (symtab)
2940 {
2941 yylval.bval = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab),
2942 STATIC_BLOCK);
2943 return FILENAME;
2944 }
2945 }
2946 }
2947
2948 if (bsym.symbol && SYMBOL_CLASS (bsym.symbol) == LOC_TYPEDEF)
2949 {
2950 yylval.tsym.type = SYMBOL_TYPE (bsym.symbol);
2951 return TYPENAME;
2952 }
2953
2954 /* See if it's an ObjC classname. */
2955 if (parse_language (par_state)->la_language == language_objc && !bsym.symbol)
2956 {
2957 CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
2958 if (Class)
2959 {
2960 struct symbol *sym;
2961
2962 yylval.theclass.theclass = Class;
2963 sym = lookup_struct_typedef (copy, expression_context_block, 1);
2964 if (sym)
2965 yylval.theclass.type = SYMBOL_TYPE (sym);
2966 return CLASSNAME;
2967 }
2968 }
2969
2970 /* Input names that aren't symbols but ARE valid hex numbers, when
2971 the input radix permits them, can be names or numbers depending
2972 on the parse. Note we support radixes > 16 here. */
2973 if (!bsym.symbol
2974 && ((copy[0] >= 'a' && copy[0] < 'a' + input_radix - 10)
2975 || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)))
2976 {
2977 YYSTYPE newlval; /* Its value is ignored. */
2978 int hextype = parse_number (par_state, copy, yylval.sval.length,
2979 0, &newlval);
2980
2981 if (hextype == INT)
2982 {
2983 yylval.ssym.sym = bsym;
2984 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2985 return NAME_OR_INT;
2986 }
2987 }
2988
2989 /* Any other kind of symbol */
2990 yylval.ssym.sym = bsym;
2991 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
2992
2993 if (bsym.symbol == NULL
2994 && parse_language (par_state)->la_language == language_cplus
2995 && is_a_field_of_this.type == NULL
2996 && lookup_minimal_symbol (copy, NULL, NULL).minsym == NULL)
2997 return UNKNOWN_CPP_NAME;
2998
2999 return NAME;
3000 }
3001
3002 /* Like classify_name, but used by the inner loop of the lexer, when a
3003 name might have already been seen. CONTEXT is the context type, or
3004 NULL if this is the first component of a name. */
3005
3006 static int
3007 classify_inner_name (struct parser_state *par_state,
3008 const struct block *block, struct type *context)
3009 {
3010 struct type *type;
3011 char *copy;
3012
3013 if (context == NULL)
3014 return classify_name (par_state, block, false, false);
3015
3016 type = check_typedef (context);
3017 if (!type_aggregate_p (type))
3018 return ERROR;
3019
3020 copy = copy_name (yylval.ssym.stoken);
3021 /* N.B. We assume the symbol can only be in VAR_DOMAIN. */
3022 yylval.ssym.sym = cp_lookup_nested_symbol (type, copy, block, VAR_DOMAIN);
3023
3024 /* If no symbol was found, search for a matching base class named
3025 COPY. This will allow users to enter qualified names of class members
3026 relative to the `this' pointer. */
3027 if (yylval.ssym.sym.symbol == NULL)
3028 {
3029 struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
3030
3031 if (base_type != NULL)
3032 {
3033 yylval.tsym.type = base_type;
3034 return TYPENAME;
3035 }
3036
3037 return ERROR;
3038 }
3039
3040 switch (SYMBOL_CLASS (yylval.ssym.sym.symbol))
3041 {
3042 case LOC_BLOCK:
3043 case LOC_LABEL:
3044 /* cp_lookup_nested_symbol might have accidentally found a constructor
3045 named COPY when we really wanted a base class of the same name.
3046 Double-check this case by looking for a base class. */
3047 {
3048 struct type *base_type = cp_find_type_baseclass_by_name (type, copy);
3049
3050 if (base_type != NULL)
3051 {
3052 yylval.tsym.type = base_type;
3053 return TYPENAME;
3054 }
3055 }
3056 return ERROR;
3057
3058 case LOC_TYPEDEF:
3059 yylval.tsym.type = SYMBOL_TYPE (yylval.ssym.sym.symbol);
3060 return TYPENAME;
3061
3062 default:
3063 return NAME;
3064 }
3065 internal_error (__FILE__, __LINE__, _("not reached"));
3066 }
3067
3068 /* The outer level of a two-level lexer. This calls the inner lexer
3069 to return tokens. It then either returns these tokens, or
3070 aggregates them into a larger token. This lets us work around a
3071 problem in our parsing approach, where the parser could not
3072 distinguish between qualified names and qualified types at the
3073 right point.
3074
3075 This approach is still not ideal, because it mishandles template
3076 types. See the comment in lex_one_token for an example. However,
3077 this is still an improvement over the earlier approach, and will
3078 suffice until we move to better parsing technology. */
3079
3080 static int
3081 yylex (void)
3082 {
3083 token_and_value current;
3084 int first_was_coloncolon, last_was_coloncolon;
3085 struct type *context_type = NULL;
3086 int last_to_examine, next_to_examine, checkpoint;
3087 const struct block *search_block;
3088 bool is_quoted_name, last_lex_was_structop;
3089
3090 if (popping && !token_fifo.empty ())
3091 goto do_pop;
3092 popping = 0;
3093
3094 last_lex_was_structop = last_was_structop;
3095
3096 /* Read the first token and decide what to do. Most of the
3097 subsequent code is C++-only; but also depends on seeing a "::" or
3098 name-like token. */
3099 current.token = lex_one_token (pstate, &is_quoted_name);
3100 if (current.token == NAME)
3101 current.token = classify_name (pstate, expression_context_block,
3102 is_quoted_name, last_lex_was_structop);
3103 if (parse_language (pstate)->la_language != language_cplus
3104 || (current.token != TYPENAME && current.token != COLONCOLON
3105 && current.token != FILENAME))
3106 return current.token;
3107
3108 /* Read any sequence of alternating "::" and name-like tokens into
3109 the token FIFO. */
3110 current.value = yylval;
3111 token_fifo.push_back (current);
3112 last_was_coloncolon = current.token == COLONCOLON;
3113 while (1)
3114 {
3115 bool ignore;
3116
3117 /* We ignore quoted names other than the very first one.
3118 Subsequent ones do not have any special meaning. */
3119 current.token = lex_one_token (pstate, &ignore);
3120 current.value = yylval;
3121 token_fifo.push_back (current);
3122
3123 if ((last_was_coloncolon && current.token != NAME)
3124 || (!last_was_coloncolon && current.token != COLONCOLON))
3125 break;
3126 last_was_coloncolon = !last_was_coloncolon;
3127 }
3128 popping = 1;
3129
3130 /* We always read one extra token, so compute the number of tokens
3131 to examine accordingly. */
3132 last_to_examine = token_fifo.size () - 2;
3133 next_to_examine = 0;
3134
3135 current = token_fifo[next_to_examine];
3136 ++next_to_examine;
3137
3138 name_obstack.clear ();
3139 checkpoint = 0;
3140 if (current.token == FILENAME)
3141 search_block = current.value.bval;
3142 else if (current.token == COLONCOLON)
3143 search_block = NULL;
3144 else
3145 {
3146 gdb_assert (current.token == TYPENAME);
3147 search_block = expression_context_block;
3148 obstack_grow (&name_obstack, current.value.sval.ptr,
3149 current.value.sval.length);
3150 context_type = current.value.tsym.type;
3151 checkpoint = 1;
3152 }
3153
3154 first_was_coloncolon = current.token == COLONCOLON;
3155 last_was_coloncolon = first_was_coloncolon;
3156
3157 while (next_to_examine <= last_to_examine)
3158 {
3159 token_and_value next;
3160
3161 next = token_fifo[next_to_examine];
3162 ++next_to_examine;
3163
3164 if (next.token == NAME && last_was_coloncolon)
3165 {
3166 int classification;
3167
3168 yylval = next.value;
3169 classification = classify_inner_name (pstate, search_block,
3170 context_type);
3171 /* We keep going until we either run out of names, or until
3172 we have a qualified name which is not a type. */
3173 if (classification != TYPENAME && classification != NAME)
3174 break;
3175
3176 /* Accept up to this token. */
3177 checkpoint = next_to_examine;
3178
3179 /* Update the partial name we are constructing. */
3180 if (context_type != NULL)
3181 {
3182 /* We don't want to put a leading "::" into the name. */
3183 obstack_grow_str (&name_obstack, "::");
3184 }
3185 obstack_grow (&name_obstack, next.value.sval.ptr,
3186 next.value.sval.length);
3187
3188 yylval.sval.ptr = (const char *) obstack_base (&name_obstack);
3189 yylval.sval.length = obstack_object_size (&name_obstack);
3190 current.value = yylval;
3191 current.token = classification;
3192
3193 last_was_coloncolon = 0;
3194
3195 if (classification == NAME)
3196 break;
3197
3198 context_type = yylval.tsym.type;
3199 }
3200 else if (next.token == COLONCOLON && !last_was_coloncolon)
3201 last_was_coloncolon = 1;
3202 else
3203 {
3204 /* We've reached the end of the name. */
3205 break;
3206 }
3207 }
3208
3209 /* If we have a replacement token, install it as the first token in
3210 the FIFO, and delete the other constituent tokens. */
3211 if (checkpoint > 0)
3212 {
3213 current.value.sval.ptr
3214 = (const char *) obstack_copy0 (&expansion_obstack,
3215 current.value.sval.ptr,
3216 current.value.sval.length);
3217
3218 token_fifo[0] = current;
3219 if (checkpoint > 1)
3220 token_fifo.erase (token_fifo.begin () + 1,
3221 token_fifo.begin () + checkpoint);
3222 }
3223
3224 do_pop:
3225 current = token_fifo[0];
3226 token_fifo.erase (token_fifo.begin ());
3227 yylval = current.value;
3228 return current.token;
3229 }
3230
3231 int
3232 c_parse (struct parser_state *par_state)
3233 {
3234 int result;
3235 struct cleanup *back_to;
3236
3237 /* Setting up the parser state. */
3238 scoped_restore pstate_restore = make_scoped_restore (&pstate);
3239 gdb_assert (par_state != NULL);
3240 pstate = par_state;
3241
3242 gdb::unique_xmalloc_ptr<struct macro_scope> macro_scope;
3243
3244 if (expression_context_block)
3245 macro_scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
3246 else
3247 macro_scope = default_macro_scope ();
3248 if (! macro_scope)
3249 macro_scope = user_macro_scope ();
3250
3251 scoped_restore restore_macro_scope
3252 = make_scoped_restore (&expression_macro_scope, macro_scope.get ());
3253
3254 /* Initialize macro expansion code. */
3255 obstack_init (&expansion_obstack);
3256 gdb_assert (! macro_original_text);
3257 /* Note that parsing (within yyparse) freely installs cleanups
3258 assuming they'll be run here (below). */
3259 back_to = make_cleanup (scan_macro_cleanup, 0);
3260
3261 scoped_restore restore_yydebug = make_scoped_restore (&yydebug,
3262 parser_debug);
3263
3264 /* Initialize some state used by the lexer. */
3265 last_was_structop = false;
3266 saw_name_at_eof = 0;
3267
3268 token_fifo.clear ();
3269 popping = 0;
3270 name_obstack.clear ();
3271
3272 result = yyparse ();
3273 do_cleanups (back_to);
3274
3275 return result;
3276 }
3277
3278 #ifdef YYBISON
3279
3280 /* This is called via the YYPRINT macro when parser debugging is
3281 enabled. It prints a token's value. */
3282
3283 static void
3284 c_print_token (FILE *file, int type, YYSTYPE value)
3285 {
3286 switch (type)
3287 {
3288 case INT:
3289 parser_fprintf (file, "typed_val_int<%s, %s>",
3290 TYPE_SAFE_NAME (value.typed_val_int.type),
3291 pulongest (value.typed_val_int.val));
3292 break;
3293
3294 case CHAR:
3295 case STRING:
3296 {
3297 char *copy = (char *) alloca (value.tsval.length + 1);
3298
3299 memcpy (copy, value.tsval.ptr, value.tsval.length);
3300 copy[value.tsval.length] = '\0';
3301
3302 parser_fprintf (file, "tsval<type=%d, %s>", value.tsval.type, copy);
3303 }
3304 break;
3305
3306 case NSSTRING:
3307 case VARIABLE:
3308 parser_fprintf (file, "sval<%s>", copy_name (value.sval));
3309 break;
3310
3311 case TYPENAME:
3312 parser_fprintf (file, "tsym<type=%s, name=%s>",
3313 TYPE_SAFE_NAME (value.tsym.type),
3314 copy_name (value.tsym.stoken));
3315 break;
3316
3317 case NAME:
3318 case UNKNOWN_CPP_NAME:
3319 case NAME_OR_INT:
3320 case BLOCKNAME:
3321 parser_fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
3322 copy_name (value.ssym.stoken),
3323 (value.ssym.sym.symbol == NULL
3324 ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym.symbol)),
3325 value.ssym.is_a_field_of_this);
3326 break;
3327
3328 case FILENAME:
3329 parser_fprintf (file, "bval<%s>", host_address_to_string (value.bval));
3330 break;
3331 }
3332 }
3333
3334 #endif
3335
3336 static void
3337 yyerror (const char *msg)
3338 {
3339 if (prev_lexptr)
3340 lexptr = prev_lexptr;
3341
3342 error (_("A %s in expression, near `%s'."), msg, lexptr);
3343 }
GDB Binutils - Deliverables
This page took 0.109388 seconds and 4 git commands to generate.