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