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