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