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