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