1 /* YACC parser for C expressions, for GDB.
3 Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 2002, 2006, 2007, 2008,
4 2009 Free Software Foundation, Inc.
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.
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.
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/>. */
19 /* Parse a C expression from text in a string, and return the result
20 as a struct expression pointer. That structure contains arithmetic
21 operations in reverse polish, with constants represented by
22 operations that are followed by special data. See expression.h for
23 the details of the format. What is important here is that it can
24 be built up sequentially during the process of parsing; the lower
25 levels of the tree always come first in the result.
27 Note that malloc's and realloc's in this file are transformed to
28 xmalloc and xrealloc respectively by the same sed command in the
29 makefile that remaps any other malloc/realloc inserted by the
30 parser generator. Doing this with #defines and trying to control
31 the interaction with include files (<malloc.h> and <stdlib.h> for
32 example) just became too messy, particularly when such includes can
33 be inserted at random times by the parser generator. */
38 #include "gdb_string.h"
40 #include "expression.h"
42 #include "objc-lang.h" /* For objc language constructs. */
45 #include "parser-defs.h"
48 #include "bfd.h" /* Required by objfiles.h. */
49 #include "symfile.h" /* Required by objfiles.h. */
50 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
52 #include "completer.h" /* For skip_quoted(). */
55 #define parse_type builtin_type (parse_gdbarch)
57 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
58 etc), as well as gratuitiously global symbol names, so we can have
59 multiple yacc generated parsers in gdb. Note that these are only
60 the variables produced by yacc. If other parser generators (bison,
61 byacc, etc) produce additional global names that conflict at link
62 time, then those parser generators need to be fixed instead of
63 adding those names to this list. */
65 #define yymaxdepth objc_maxdepth
66 #define yyparse objc_parse
67 #define yylex objc_lex
68 #define yyerror objc_error
69 #define yylval objc_lval
70 #define yychar objc_char
71 #define yydebug objc_debug
72 #define yypact objc_pact
75 #define yydef objc_def
76 #define yychk objc_chk
77 #define yypgo objc_pgo
78 #define yyact objc_act
79 #define yyexca objc_exca
80 #define yyerrflag objc_errflag
81 #define yynerrs objc_nerrs
85 #define yy_yys objc_yys
86 #define yystate objc_state
87 #define yytmp objc_tmp
89 #define yy_yyv objc_yyv
90 #define yyval objc_val
91 #define yylloc objc_lloc
92 #define yyreds objc_reds /* With YYDEBUG defined */
93 #define yytoks objc_toks /* With YYDEBUG defined */
94 #define yyname objc_name /* With YYDEBUG defined */
95 #define yyrule objc_rule /* With YYDEBUG defined */
96 #define yylhs objc_yylhs
97 #define yylen objc_yylen
98 #define yydefred objc_yydefred
99 #define yydgoto objc_yydgoto
100 #define yysindex objc_yysindex
101 #define yyrindex objc_yyrindex
102 #define yygindex objc_yygindex
103 #define yytable objc_yytable
104 #define yycheck objc_yycheck
107 #define YYDEBUG 0 /* Default to no yydebug support. */
121 /* Although the yacc "value" of an expression is not used,
122 since the result is stored in the structure being created,
123 other node types do have values. */
140 struct symtoken ssym
;
143 enum exp_opcode opcode
;
144 struct internalvar
*ivar
;
145 struct objc_class_str class
;
152 /* YYSTYPE gets defined by %union. */
154 parse_number
(char *, int, int, YYSTYPE *);
157 %type
<voidval
> exp exp1 type_exp start variable qualified_name lcurly
159 %type
<tval
> type typebase
160 %type
<tvec
> nonempty_typelist
161 /* %type <bval> block */
163 /* Fancy type parsing. */
164 %type
<voidval
> func_mod direct_abs_decl abs_decl
166 %type
<lval
> array_mod
168 %token
<typed_val_int
> INT
169 %token
<typed_val_float
> FLOAT
171 /* Both NAME and TYPENAME tokens represent symbols in the input, and
172 both convey their data as strings. But a TYPENAME is a string that
173 happens to be defined as a typedef or builtin type name (such as
174 int or char) and a NAME is any other symbol. Contexts where this
175 distinction is not important can use the nonterminal "name", which
176 matches either NAME or TYPENAME. */
179 %token
<sval
> NSSTRING
/* ObjC Foundation "NSString" literal */
180 %token
<sval
> SELECTOR
/* ObjC "@selector" pseudo-operator */
181 %token
<ssym
> NAME
/* BLOCKNAME defined below to give it higher precedence. */
182 %token
<tsym
> TYPENAME
183 %token
<class
> CLASSNAME
/* ObjC Class name */
185 %type
<ssym
> name_not_typename
186 %type
<tsym
> typename
188 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
189 but which would parse as a valid number in the current input radix.
190 E.g. "c" when input_radix==16. Depending on the parse, it will be
191 turned into a name or into a number. */
193 %token
<ssym
> NAME_OR_INT
195 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
199 /* Special type cases, put in to allow the parser to distinguish
200 different legal basetypes. */
201 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
203 %token
<voidval
> VARIABLE
205 %token
<opcode
> ASSIGN_MODIFY
209 %right
'=' ASSIGN_MODIFY
217 %left
'<' '>' LEQ GEQ
222 %right UNARY INCREMENT DECREMENT
223 %right ARROW
'.' '[' '('
224 %token
<ssym
> BLOCKNAME
236 { write_exp_elt_opcode
(OP_TYPE
);
237 write_exp_elt_type
($1);
238 write_exp_elt_opcode
(OP_TYPE
);}
241 /* Expressions, including the comma operator. */
244 { write_exp_elt_opcode
(BINOP_COMMA
); }
247 /* Expressions, not including the comma operator. */
248 exp
: '*' exp %prec UNARY
249 { write_exp_elt_opcode
(UNOP_IND
); }
252 exp
: '&' exp %prec UNARY
253 { write_exp_elt_opcode
(UNOP_ADDR
); }
256 exp
: '-' exp %prec UNARY
257 { write_exp_elt_opcode
(UNOP_NEG
); }
260 exp
: '!' exp %prec UNARY
261 { write_exp_elt_opcode
(UNOP_LOGICAL_NOT
); }
264 exp
: '~' exp %prec UNARY
265 { write_exp_elt_opcode
(UNOP_COMPLEMENT
); }
268 exp
: INCREMENT exp %prec UNARY
269 { write_exp_elt_opcode
(UNOP_PREINCREMENT
); }
272 exp
: DECREMENT exp %prec UNARY
273 { write_exp_elt_opcode
(UNOP_PREDECREMENT
); }
276 exp
: exp INCREMENT %prec UNARY
277 { write_exp_elt_opcode
(UNOP_POSTINCREMENT
); }
280 exp
: exp DECREMENT %prec UNARY
281 { write_exp_elt_opcode
(UNOP_POSTDECREMENT
); }
284 exp
: SIZEOF exp %prec UNARY
285 { write_exp_elt_opcode
(UNOP_SIZEOF
); }
289 { write_exp_elt_opcode
(STRUCTOP_PTR
);
290 write_exp_string
($3);
291 write_exp_elt_opcode
(STRUCTOP_PTR
); }
294 exp
: exp ARROW qualified_name
295 { /* exp->type::name becomes exp->*(&type::name) */
296 /* Note: this doesn't work if name is a
297 static member! FIXME */
298 write_exp_elt_opcode
(UNOP_ADDR
);
299 write_exp_elt_opcode
(STRUCTOP_MPTR
); }
301 exp
: exp ARROW
'*' exp
302 { write_exp_elt_opcode
(STRUCTOP_MPTR
); }
306 { write_exp_elt_opcode
(STRUCTOP_STRUCT
);
307 write_exp_string
($3);
308 write_exp_elt_opcode
(STRUCTOP_STRUCT
); }
312 exp
: exp
'.' qualified_name
313 { /* exp.type::name becomes exp.*(&type::name) */
314 /* Note: this doesn't work if name is a
315 static member! FIXME */
316 write_exp_elt_opcode
(UNOP_ADDR
);
317 write_exp_elt_opcode
(STRUCTOP_MEMBER
); }
320 exp
: exp
'.' '*' exp
321 { write_exp_elt_opcode
(STRUCTOP_MEMBER
); }
324 exp
: exp
'[' exp1
']'
325 { write_exp_elt_opcode
(BINOP_SUBSCRIPT
); }
328 * The rules below parse ObjC message calls of the form:
329 * '[' target selector {':' argument}* ']'
336 class
= lookup_objc_class
(copy_name
($2.stoken
));
338 error ("%s is not an ObjC Class",
339 copy_name
($2.stoken
));
340 write_exp_elt_opcode
(OP_LONG
);
341 write_exp_elt_type
(parse_type
->builtin_int
);
342 write_exp_elt_longcst
((LONGEST
) class
);
343 write_exp_elt_opcode
(OP_LONG
);
347 { write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
349 write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
355 write_exp_elt_opcode
(OP_LONG
);
356 write_exp_elt_type
(parse_type
->builtin_int
);
357 write_exp_elt_longcst
((LONGEST
) $2.class
);
358 write_exp_elt_opcode
(OP_LONG
);
362 { write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
364 write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
371 { write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
373 write_exp_elt_opcode
(OP_OBJC_MSGCALL
);
378 { add_msglist
(&$1, 0); }
386 msgarg
: name
':' exp
387 { add_msglist
(&$1, 1); }
388 |
':' exp
/* Unnamed arg. */
389 { add_msglist
(0, 1); }
390 |
',' exp
/* Variable number of args. */
391 { add_msglist
(0, 0); }
395 /* This is to save the value of arglist_len
396 being accumulated by an outer function call. */
397 { start_arglist
(); }
398 arglist
')' %prec ARROW
399 { write_exp_elt_opcode
(OP_FUNCALL
);
400 write_exp_elt_longcst
((LONGEST
) end_arglist
());
401 write_exp_elt_opcode
(OP_FUNCALL
); }
405 { start_arglist
(); }
415 arglist
: arglist
',' exp %prec ABOVE_COMMA
420 { $$
= end_arglist
() - 1; }
422 exp
: lcurly arglist rcurly %prec ARROW
423 { write_exp_elt_opcode
(OP_ARRAY
);
424 write_exp_elt_longcst
((LONGEST
) 0);
425 write_exp_elt_longcst
((LONGEST
) $3);
426 write_exp_elt_opcode
(OP_ARRAY
); }
429 exp
: lcurly type rcurly exp %prec UNARY
430 { write_exp_elt_opcode
(UNOP_MEMVAL
);
431 write_exp_elt_type
($2);
432 write_exp_elt_opcode
(UNOP_MEMVAL
); }
435 exp
: '(' type
')' exp %prec UNARY
436 { write_exp_elt_opcode
(UNOP_CAST
);
437 write_exp_elt_type
($2);
438 write_exp_elt_opcode
(UNOP_CAST
); }
445 /* Binary operators in order of decreasing precedence. */
448 { write_exp_elt_opcode
(BINOP_REPEAT
); }
452 { write_exp_elt_opcode
(BINOP_MUL
); }
456 { write_exp_elt_opcode
(BINOP_DIV
); }
460 { write_exp_elt_opcode
(BINOP_REM
); }
464 { write_exp_elt_opcode
(BINOP_ADD
); }
468 { write_exp_elt_opcode
(BINOP_SUB
); }
472 { write_exp_elt_opcode
(BINOP_LSH
); }
476 { write_exp_elt_opcode
(BINOP_RSH
); }
480 { write_exp_elt_opcode
(BINOP_EQUAL
); }
483 exp
: exp NOTEQUAL exp
484 { write_exp_elt_opcode
(BINOP_NOTEQUAL
); }
488 { write_exp_elt_opcode
(BINOP_LEQ
); }
492 { write_exp_elt_opcode
(BINOP_GEQ
); }
496 { write_exp_elt_opcode
(BINOP_LESS
); }
500 { write_exp_elt_opcode
(BINOP_GTR
); }
504 { write_exp_elt_opcode
(BINOP_BITWISE_AND
); }
508 { write_exp_elt_opcode
(BINOP_BITWISE_XOR
); }
512 { write_exp_elt_opcode
(BINOP_BITWISE_IOR
); }
516 { write_exp_elt_opcode
(BINOP_LOGICAL_AND
); }
520 { write_exp_elt_opcode
(BINOP_LOGICAL_OR
); }
523 exp
: exp
'?' exp
':' exp %prec
'?'
524 { write_exp_elt_opcode
(TERNOP_COND
); }
528 { write_exp_elt_opcode
(BINOP_ASSIGN
); }
531 exp
: exp ASSIGN_MODIFY exp
532 { write_exp_elt_opcode
(BINOP_ASSIGN_MODIFY
);
533 write_exp_elt_opcode
($2);
534 write_exp_elt_opcode
(BINOP_ASSIGN_MODIFY
); }
538 { write_exp_elt_opcode
(OP_LONG
);
539 write_exp_elt_type
($1.type
);
540 write_exp_elt_longcst
((LONGEST
)($1.val
));
541 write_exp_elt_opcode
(OP_LONG
); }
546 parse_number
($1.stoken.ptr
, $1.stoken.length
, 0, &val
);
547 write_exp_elt_opcode
(OP_LONG
);
548 write_exp_elt_type
(val.typed_val_int.type
);
549 write_exp_elt_longcst
((LONGEST
)val.typed_val_int.val
);
550 write_exp_elt_opcode
(OP_LONG
);
556 { write_exp_elt_opcode
(OP_DOUBLE
);
557 write_exp_elt_type
($1.type
);
558 write_exp_elt_dblcst
($1.dval
);
559 write_exp_elt_opcode
(OP_DOUBLE
); }
566 /* Already written by write_dollar_variable. */
571 write_exp_elt_opcode
(OP_OBJC_SELECTOR
);
572 write_exp_string
($1);
573 write_exp_elt_opcode
(OP_OBJC_SELECTOR
); }
576 exp
: SIZEOF
'(' type
')' %prec UNARY
577 { write_exp_elt_opcode
(OP_LONG
);
578 write_exp_elt_type
(parse_type
->builtin_int
);
580 write_exp_elt_longcst
((LONGEST
) TYPE_LENGTH
($3));
581 write_exp_elt_opcode
(OP_LONG
); }
585 { /* C strings are converted into array
586 constants with an explicit null byte
587 added at the end. Thus the array upper
588 bound is the string length. There is no
589 such thing in C as a completely empty
591 char *sp
= $1.ptr
; int count
= $1.length
;
594 write_exp_elt_opcode
(OP_LONG
);
595 write_exp_elt_type
(parse_type
->builtin_char
);
596 write_exp_elt_longcst
((LONGEST
)(*sp
++));
597 write_exp_elt_opcode
(OP_LONG
);
599 write_exp_elt_opcode
(OP_LONG
);
600 write_exp_elt_type
(parse_type
->builtin_char
);
601 write_exp_elt_longcst
((LONGEST
)'\0');
602 write_exp_elt_opcode
(OP_LONG
);
603 write_exp_elt_opcode
(OP_ARRAY
);
604 write_exp_elt_longcst
((LONGEST
) 0);
605 write_exp_elt_longcst
((LONGEST
) ($1.length
));
606 write_exp_elt_opcode
(OP_ARRAY
); }
609 exp
: NSSTRING
/* ObjC NextStep NSString constant
610 * of the form '@' '"' string '"'.
612 { write_exp_elt_opcode
(OP_OBJC_NSSTRING
);
613 write_exp_string
($1);
614 write_exp_elt_opcode
(OP_OBJC_NSSTRING
); }
620 $$
= SYMBOL_BLOCK_VALUE
($1.sym
);
624 lookup_symtab
(copy_name
($1.stoken
));
626 $$
= BLOCKVECTOR_BLOCK
(BLOCKVECTOR
(tem
), STATIC_BLOCK
);
628 error ("No file or function \"%s\".",
629 copy_name
($1.stoken
));
634 block
: block COLONCOLON name
636 = lookup_symbol
(copy_name
($3), $1,
637 VAR_DOMAIN
, (int *) NULL
);
638 if
(!tem || SYMBOL_CLASS
(tem
) != LOC_BLOCK
)
639 error ("No function \"%s\" in specified context.",
641 $$
= SYMBOL_BLOCK_VALUE
(tem
); }
644 variable: block COLONCOLON name
645 { struct symbol
*sym
;
646 sym
= lookup_symbol
(copy_name
($3), $1,
647 VAR_DOMAIN
, (int *) NULL
);
649 error ("No symbol \"%s\" in specified context.",
652 write_exp_elt_opcode
(OP_VAR_VALUE
);
653 /* block_found is set by lookup_symbol. */
654 write_exp_elt_block
(block_found
);
655 write_exp_elt_sym
(sym
);
656 write_exp_elt_opcode
(OP_VAR_VALUE
); }
659 qualified_name: typebase COLONCOLON name
661 struct type
*type
= $1;
662 if
(TYPE_CODE
(type
) != TYPE_CODE_STRUCT
663 && TYPE_CODE
(type
) != TYPE_CODE_UNION
)
664 error ("`%s' is not defined as an aggregate type.",
667 write_exp_elt_opcode
(OP_SCOPE
);
668 write_exp_elt_type
(type
);
669 write_exp_string
($3);
670 write_exp_elt_opcode
(OP_SCOPE
);
672 | typebase COLONCOLON
'~' name
674 struct type
*type
= $1;
675 struct stoken tmp_token
;
676 if
(TYPE_CODE
(type
) != TYPE_CODE_STRUCT
677 && TYPE_CODE
(type
) != TYPE_CODE_UNION
)
678 error ("`%s' is not defined as an aggregate type.",
681 if
(strcmp
(type_name_no_tag
(type
), $4.ptr
) != 0)
682 error ("invalid destructor `%s::~%s'",
683 type_name_no_tag
(type
), $4.ptr
);
685 tmp_token.ptr
= (char*) alloca
($4.length
+ 2);
686 tmp_token.length
= $4.length
+ 1;
687 tmp_token.ptr
[0] = '~';
688 memcpy
(tmp_token.ptr
+1, $4.ptr
, $4.length
);
689 tmp_token.ptr
[tmp_token.length
] = 0;
690 write_exp_elt_opcode
(OP_SCOPE
);
691 write_exp_elt_type
(type
);
692 write_exp_string
(tmp_token
);
693 write_exp_elt_opcode
(OP_SCOPE
);
697 variable: qualified_name
700 char *name
= copy_name
($2);
702 struct minimal_symbol
*msymbol
;
705 lookup_symbol
(name
, (const struct block
*) NULL
,
706 VAR_DOMAIN
, (int *) NULL
);
709 write_exp_elt_opcode
(OP_VAR_VALUE
);
710 write_exp_elt_block
(NULL
);
711 write_exp_elt_sym
(sym
);
712 write_exp_elt_opcode
(OP_VAR_VALUE
);
716 msymbol
= lookup_minimal_symbol
(name
, NULL
, NULL
);
718 write_exp_msymbol
(msymbol
);
719 else if
(!have_full_symbols
() && !have_partial_symbols
())
720 error ("No symbol table is loaded. Use the \"file\" command.");
722 error ("No symbol \"%s\" in current context.", name
);
726 variable: name_not_typename
727 { struct symbol
*sym
= $1.sym
;
731 if
(symbol_read_needs_frame
(sym
))
733 if
(innermost_block
== 0 ||
734 contained_in
(block_found
,
736 innermost_block
= block_found
;
739 write_exp_elt_opcode
(OP_VAR_VALUE
);
740 /* We want to use the selected frame, not
741 another more inner frame which happens to
742 be in the same block. */
743 write_exp_elt_block
(NULL
);
744 write_exp_elt_sym
(sym
);
745 write_exp_elt_opcode
(OP_VAR_VALUE
);
747 else if
($1.is_a_field_of_this
)
749 /* C++/ObjC: it hangs off of `this'/'self'.
750 Must not inadvertently convert from a
751 method call to data ref. */
752 if
(innermost_block
== 0 ||
753 contained_in
(block_found
, innermost_block
))
754 innermost_block
= block_found
;
755 write_exp_elt_opcode
(OP_OBJC_SELF
);
756 write_exp_elt_opcode
(OP_OBJC_SELF
);
757 write_exp_elt_opcode
(STRUCTOP_PTR
);
758 write_exp_string
($1.stoken
);
759 write_exp_elt_opcode
(STRUCTOP_PTR
);
763 struct minimal_symbol
*msymbol
;
764 char *arg
= copy_name
($1.stoken
);
767 lookup_minimal_symbol
(arg
, NULL
, NULL
);
769 write_exp_msymbol
(msymbol
);
770 else if
(!have_full_symbols
() &&
771 !have_partial_symbols
())
772 error ("No symbol table is loaded. Use the \"file\" command.");
774 error ("No symbol \"%s\" in current context.",
775 copy_name
($1.stoken
));
782 /* "const" and "volatile" are curently ignored. A type
783 qualifier before the type is currently handled in the
784 typebase rule. The reason for recognizing these here
785 (shift/reduce conflicts) might be obsolete now that some
786 pointer to member rules have been deleted. */
787 | typebase CONST_KEYWORD
788 | typebase VOLATILE_KEYWORD
790 { $$
= follow_types
($1); }
791 | typebase CONST_KEYWORD abs_decl
792 { $$
= follow_types
($1); }
793 | typebase VOLATILE_KEYWORD abs_decl
794 { $$
= follow_types
($1); }
798 { push_type
(tp_pointer
); $$
= 0; }
800 { push_type
(tp_pointer
); $$
= $2; }
802 { push_type
(tp_reference
); $$
= 0; }
804 { push_type
(tp_reference
); $$
= $2; }
808 direct_abs_decl: '(' abs_decl
')'
810 | direct_abs_decl array_mod
813 push_type
(tp_array
);
818 push_type
(tp_array
);
822 | direct_abs_decl func_mod
823 { push_type
(tp_function
); }
825 { push_type
(tp_function
); }
836 |
'(' nonempty_typelist
')'
837 { free
($2); $$
= 0; }
840 /* We used to try to recognize more pointer to member types here, but
841 that didn't work (shift/reduce conflicts meant that these rules
842 never got executed). The problem is that
843 int (foo::bar::baz::bizzle)
844 is a function type but
845 int (foo::bar::baz::bizzle::*)
846 is a pointer to member type. Stroustrup loses again! */
851 typebase
/* Implements (approximately): (type-qualifier)* type-specifier. */
857 error ("No symbol \"%s\" in current context.",
858 copy_name
($1.stoken
));
863 { $$
= parse_type
->builtin_int
; }
865 { $$
= parse_type
->builtin_long
; }
867 { $$
= parse_type
->builtin_short
; }
869 { $$
= parse_type
->builtin_long
; }
870 | UNSIGNED LONG INT_KEYWORD
871 { $$
= parse_type
->builtin_unsigned_long
; }
873 { $$
= parse_type
->builtin_long_long
; }
874 | LONG LONG INT_KEYWORD
875 { $$
= parse_type
->builtin_long_long
; }
877 { $$
= parse_type
->builtin_unsigned_long_long
; }
878 | UNSIGNED LONG LONG INT_KEYWORD
879 { $$
= parse_type
->builtin_unsigned_long_long
; }
881 { $$
= parse_type
->builtin_short
; }
882 | UNSIGNED SHORT INT_KEYWORD
883 { $$
= parse_type
->builtin_unsigned_short
; }
885 { $$
= parse_type
->builtin_double
; }
886 | LONG DOUBLE_KEYWORD
887 { $$
= parse_type
->builtin_long_double
; }
889 { $$
= lookup_struct
(copy_name
($2),
890 expression_context_block
); }
892 { $$
= lookup_struct
(copy_name
($2),
893 expression_context_block
); }
895 { $$
= lookup_union
(copy_name
($2),
896 expression_context_block
); }
898 { $$
= lookup_enum
(copy_name
($2),
899 expression_context_block
); }
901 { $$
= lookup_unsigned_typename
(TYPE_NAME
($2.type
)); }
903 { $$
= parse_type
->builtin_unsigned_int
; }
904 | SIGNED_KEYWORD typename
905 { $$
= lookup_signed_typename
(TYPE_NAME
($2.type
)); }
907 { $$
= parse_type
->builtin_int
; }
908 | TEMPLATE name
'<' type
'>'
909 { $$
= lookup_template_type
(copy_name
($2), $4,
910 expression_context_block
);
912 /* "const" and "volatile" are curently ignored. A type
913 qualifier after the type is handled in the ptype rule. I
914 think these could be too. */
915 | CONST_KEYWORD typebase
{ $$
= $2; }
916 | VOLATILE_KEYWORD typebase
{ $$
= $2; }
922 $$.stoken.ptr
= "int";
923 $$.stoken.length
= 3;
924 $$.type
= parse_type
->builtin_int
;
928 $$.stoken.ptr
= "long";
929 $$.stoken.length
= 4;
930 $$.type
= parse_type
->builtin_long
;
934 $$.stoken.ptr
= "short";
935 $$.stoken.length
= 5;
936 $$.type
= parse_type
->builtin_short
;
942 { $$
= (struct type
**) malloc
(sizeof
(struct type
*) * 2);
943 $
<ivec
>$
[0] = 1; /* Number of types in vector. */
946 | nonempty_typelist
',' type
947 { int len
= sizeof
(struct type
*) * (++($
<ivec
>1[0]) + 1);
948 $$
= (struct type
**) realloc
((char *) $1, len
);
949 $$
[$
<ivec
>$
[0]] = $3;
953 name
: NAME
{ $$
= $1.stoken
; }
954 | BLOCKNAME
{ $$
= $1.stoken
; }
955 | TYPENAME
{ $$
= $1.stoken
; }
956 | CLASSNAME
{ $$
= $1.stoken
; }
957 | NAME_OR_INT
{ $$
= $1.stoken
; }
960 name_not_typename
: NAME
962 /* These would be useful if name_not_typename was useful, but it is
963 just a fake for "variable", so these cause reduce/reduce conflicts
964 because the parser can't tell whether NAME_OR_INT is a
965 name_not_typename (=variable, =exp) or just an exp. If
966 name_not_typename was ever used in an lvalue context where only a
967 name could occur, this might be useful. */
973 /* Take care of parsing a number (anything that starts with a digit).
974 Set yylval and return the token type; update lexptr. LEN is the
975 number of characters in it. */
977 /*** Needs some error checking for the float case. ***/
980 parse_number
(p
, len
, parsed_float
, putithere
)
986 /* FIXME: Shouldn't these be unsigned? We don't deal with negative
987 values here, and we do kind of silly things like cast to
995 int base
= input_radix
;
998 /* Number of "L" suffixes encountered. */
1001 /* We have found a "L" or "U" suffix. */
1002 int found_suffix
= 0;
1004 unsigned LONGEST high_bit
;
1005 struct type
*signed_type
;
1006 struct type
*unsigned_type
;
1012 /* It's a float since it contains a point or an exponent. */
1014 sscanf
(p
, "%" DOUBLEST_SCAN_FORMAT
"%c",
1015 &putithere
->typed_val_float.dval
, &c
);
1017 /* See if it has `f' or `l' suffix (float or long double). */
1019 c
= tolower
(p
[len
- 1]);
1022 putithere
->typed_val_float.type
= parse_type
->builtin_float
;
1024 putithere
->typed_val_float.type
= parse_type
->builtin_long_double
;
1025 else if
(isdigit
(c
) || c
== '.')
1026 putithere
->typed_val_float.type
= parse_type
->builtin_double
;
1033 /* Handle base-switching prefixes 0x, 0t, 0d, and 0. */
1067 if
(c
>= 'A' && c
<= 'Z')
1069 if
(c
!= 'l' && c
!= 'u')
1071 if
(c
>= '0' && c
<= '9')
1079 if
(base
> 10 && c
>= 'a' && c
<= 'f')
1083 n
+= i
= c
- 'a' + 10;
1096 return ERROR
; /* Char not a digit. */
1099 return ERROR
; /* Invalid digit in this base. */
1101 /* Portably test for overflow (only works for nonzero values, so
1102 make a second check for zero). FIXME: Can't we just make n
1103 and prevn unsigned and avoid this? */
1104 if
(c
!= 'l' && c
!= 'u' && (prevn
>= n
) && n
!= 0)
1105 unsigned_p
= 1; /* Try something unsigned. */
1107 /* Portably test for unsigned overflow.
1108 FIXME: This check is wrong; for example it doesn't find
1109 overflow on 0x123456789 when LONGEST is 32 bits. */
1110 if
(c
!= 'l' && c
!= 'u' && n
!= 0)
1112 if
((unsigned_p
&& (unsigned LONGEST
) prevn
>= (unsigned LONGEST
) n
))
1113 error ("Numeric constant too large.");
1118 /* An integer constant is an int, a long, or a long long. An L
1119 suffix forces it to be long; an LL suffix forces it to be long
1120 long. If not forced to a larger size, it gets the first type of
1121 the above that it fits in. To figure out whether it fits, we
1122 shift it right and see whether anything remains. Note that we
1123 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1124 operation, because many compilers will warn about such a shift
1125 (which always produces a zero result). Sometimes gdbarch_int_bit
1126 or gdbarch_long_int will be that big, sometimes not. To deal with
1127 the case where it is we just always shift the value more than
1128 once, with fewer bits each time. */
1130 un
= (unsigned LONGEST
)n
>> 2;
1132 && (un
>> (gdbarch_int_bit
(parse_gdbarch
) - 2)) == 0)
1134 high_bit
= ((unsigned LONGEST
)1) << (gdbarch_int_bit
(parse_gdbarch
) - 1);
1136 /* A large decimal (not hex or octal) constant (between INT_MAX
1137 and UINT_MAX) is a long or unsigned long, according to ANSI,
1138 never an unsigned int, but this code treats it as unsigned
1139 int. This probably should be fixed. GCC gives a warning on
1142 unsigned_type
= parse_type
->builtin_unsigned_int
;
1143 signed_type
= parse_type
->builtin_int
;
1145 else if
(long_p
<= 1
1146 && (un
>> (gdbarch_long_bit
(parse_gdbarch
) - 2)) == 0)
1148 high_bit
= ((unsigned LONGEST
)1) << (gdbarch_long_bit
(parse_gdbarch
) - 1);
1149 unsigned_type
= parse_type
->builtin_unsigned_long
;
1150 signed_type
= parse_type
->builtin_long
;
1154 high_bit
= (((unsigned LONGEST
)1)
1155 << (gdbarch_long_long_bit
(parse_gdbarch
) - 32 - 1)
1159 /* A long long does not fit in a LONGEST. */
1161 (unsigned LONGEST
)1 << (sizeof
(LONGEST
) * HOST_CHAR_BIT
- 1);
1162 unsigned_type
= parse_type
->builtin_unsigned_long_long
;
1163 signed_type
= parse_type
->builtin_long_long
;
1166 putithere
->typed_val_int.val
= n
;
1168 /* If the high bit of the worked out type is set then this number
1169 has to be unsigned. */
1171 if
(unsigned_p ||
(n
& high_bit
))
1173 putithere
->typed_val_int.type
= unsigned_type
;
1177 putithere
->typed_val_int.type
= signed_type
;
1187 enum exp_opcode opcode
;
1190 static const struct token tokentab3
[] =
1192 {">>=", ASSIGN_MODIFY
, BINOP_RSH
},
1193 {"<<=", ASSIGN_MODIFY
, BINOP_LSH
}
1196 static const struct token tokentab2
[] =
1198 {"+=", ASSIGN_MODIFY
, BINOP_ADD
},
1199 {"-=", ASSIGN_MODIFY
, BINOP_SUB
},
1200 {"*=", ASSIGN_MODIFY
, BINOP_MUL
},
1201 {"/=", ASSIGN_MODIFY
, BINOP_DIV
},
1202 {"%=", ASSIGN_MODIFY
, BINOP_REM
},
1203 {"|=", ASSIGN_MODIFY
, BINOP_BITWISE_IOR
},
1204 {"&=", ASSIGN_MODIFY
, BINOP_BITWISE_AND
},
1205 {"^=", ASSIGN_MODIFY
, BINOP_BITWISE_XOR
},
1206 {"++", INCREMENT
, BINOP_END
},
1207 {"--", DECREMENT
, BINOP_END
},
1208 {"->", ARROW
, BINOP_END
},
1209 {"&&", ANDAND
, BINOP_END
},
1210 {"||", OROR
, BINOP_END
},
1211 {"::", COLONCOLON
, BINOP_END
},
1212 {"<<", LSH
, BINOP_END
},
1213 {">>", RSH
, BINOP_END
},
1214 {"==", EQUAL
, BINOP_END
},
1215 {"!=", NOTEQUAL
, BINOP_END
},
1216 {"<=", LEQ
, BINOP_END
},
1217 {">=", GEQ
, BINOP_END
}
1220 /* Read one token, getting characters through lexptr. */
1231 static char *tempbuf
;
1232 static int tempbufsize
;
1237 /* See if it is a special token of length 3. */
1238 for
(i
= 0; i
< sizeof tokentab3
/ sizeof tokentab3
[0]; i
++)
1239 if
(strncmp
(tokstart
, tokentab3
[i
].operator
, 3) == 0)
1242 yylval.opcode
= tokentab3
[i
].opcode
;
1243 return tokentab3
[i
].token
;
1246 /* See if it is a special token of length 2. */
1247 for
(i
= 0; i
< sizeof tokentab2
/ sizeof tokentab2
[0]; i
++)
1248 if
(strncmp
(tokstart
, tokentab2
[i
].operator
, 2) == 0)
1251 yylval.opcode
= tokentab2
[i
].opcode
;
1252 return tokentab2
[i
].token
;
1256 switch
(tokchr
= *tokstart
)
1268 /* We either have a character constant ('0' or '\177' for
1269 example) or we have a quoted symbol reference ('foo(int,int)'
1270 in C++ for example). */
1274 c
= parse_escape
(&lexptr
);
1276 error ("Empty character constant.");
1278 yylval.typed_val_int.val
= c
;
1279 yylval.typed_val_int.type
= parse_type
->builtin_char
;
1284 namelen
= skip_quoted
(tokstart
) - tokstart
;
1287 lexptr
= tokstart
+ namelen
;
1288 if
(lexptr
[-1] != '\'')
1289 error ("Unmatched single quote.");
1294 error ("Invalid character constant.");
1304 if
(paren_depth
== 0)
1311 if
(comma_terminates
&& paren_depth
== 0)
1317 /* Might be a floating point number. */
1318 if
(lexptr
[1] < '0' || lexptr
[1] > '9')
1319 goto symbol
; /* Nope, must be a symbol. */
1320 /* FALL THRU into number case. */
1333 /* It's a number. */
1334 int got_dot
= 0, got_e
= 0, toktype
= FLOAT
;
1335 /* Initialize toktype to anything other than ERROR. */
1337 int hex
= input_radix
> 10;
1338 int local_radix
= input_radix
;
1339 if
(tokchr
== '0' && (p
[1] == 'x' || p
[1] == 'X'))
1345 else if
(tokchr
== '0' && (p
[1]=='t' || p
[1]=='T' || p
[1]=='d' || p
[1]=='D'))
1354 /* This test includes !hex because 'e' is a valid hex digit
1355 and thus does not indicate a floating point number when
1356 the radix is hex. */
1358 if
(!hex
&& (*p
== 'e' ||
*p
== 'E'))
1360 toktype
= ERROR
; /* Only one 'e' in a float. */
1363 /* This test does not include !hex, because a '.' always
1364 indicates a decimal floating point number regardless of
1368 toktype
= ERROR
; /* Only one '.' in a float. */
1371 else if
(got_e
&& (p
[-1] == 'e' || p
[-1] == 'E') &&
1372 (*p
== '-' ||
*p
== '+'))
1373 /* This is the sign of the exponent, not the end of the
1376 /* Always take decimal digits; parse_number handles radix
1378 else if
(*p
>= '0' && *p
<= '9')
1380 /* We will take letters only if hex is true, and only up
1381 to what the input radix would permit. FSF was content
1382 to rely on parse_number to validate; but it leaks. */
1383 else if
(*p
>= 'a' && *p
<= 'z')
1385 if
(!hex ||
*p
>= ('a' + local_radix
- 10))
1388 else if
(*p
>= 'A' && *p
<= 'Z')
1390 if
(!hex ||
*p
>= ('A' + local_radix
- 10))
1395 if
(toktype
!= ERROR
)
1396 toktype
= parse_number
(tokstart
, p
- tokstart
,
1397 got_dot | got_e
, &yylval);
1398 if
(toktype
== ERROR
)
1400 char *err_copy
= (char *) alloca
(p
- tokstart
+ 1);
1402 memcpy
(err_copy
, tokstart
, p
- tokstart
);
1403 err_copy
[p
- tokstart
] = 0;
1404 error ("Invalid number \"%s\".", err_copy
);
1421 case
'@': /* Moved out below. */
1437 if
(strncmp
(tokstart
, "@selector", 9) == 0)
1439 tokptr
= strchr
(tokstart
, '(');
1442 error ("Missing '(' in @selector(...)");
1445 tokptr
++; /* Skip the '('. */
1447 /* Grow the static temp buffer if necessary, including
1448 allocating the first one on demand. */
1449 if
(tempbufindex
+ 1 >= tempbufsize
)
1451 tempbuf
= (char *) realloc
(tempbuf
, tempbufsize
+= 64);
1453 tempbuf
[tempbufindex
++] = *tokptr
++;
1454 } while
((*tokptr
!= ')') && (*tokptr
!= '\0'));
1455 if
(*tokptr
++ != ')')
1457 error ("Missing ')' in @selector(...)");
1459 tempbuf
[tempbufindex
] = '\0';
1460 yylval.sval.ptr
= tempbuf
;
1461 yylval.sval.length
= tempbufindex
;
1465 if
(tokstart
[1] != '"')
1470 /* ObjC NextStep NSString constant: fall thru and parse like
1476 /* Build the gdb internal form of the input string in tempbuf,
1477 translating any standard C escape forms seen. Note that the
1478 buffer is null byte terminated *only* for the convenience of
1479 debugging gdb itself and printing the buffer contents when
1480 the buffer contains no embedded nulls. Gdb does not depend
1481 upon the buffer being null byte terminated, it uses the
1482 length string instead. This allows gdb to handle C strings
1483 (as well as strings in other languages) with embedded null
1486 tokptr
= ++tokstart
;
1490 /* Grow the static temp buffer if necessary, including
1491 allocating the first one on demand. */
1492 if
(tempbufindex
+ 1 >= tempbufsize
)
1494 tempbuf
= (char *) realloc
(tempbuf
, tempbufsize
+= 64);
1500 /* Do nothing, loop will terminate. */
1504 c
= parse_escape
(&tokptr
);
1509 tempbuf
[tempbufindex
++] = c
;
1512 tempbuf
[tempbufindex
++] = *tokptr
++;
1515 } while
((*tokptr
!= '"') && (*tokptr
!= '\0'));
1516 if
(*tokptr
++ != '"')
1518 error ("Unterminated string in expression.");
1520 tempbuf
[tempbufindex
] = '\0'; /* See note above. */
1521 yylval.sval.ptr
= tempbuf
;
1522 yylval.sval.length
= tempbufindex
;
1524 return
(tokchr
== '@' ? NSSTRING
: STRING
);
1527 if
(!(tokchr
== '_' || tokchr
== '$' ||
1528 (tokchr
>= 'a' && tokchr
<= 'z') ||
(tokchr
>= 'A' && tokchr
<= 'Z')))
1529 /* We must have come across a bad character (e.g. ';'). */
1530 error ("Invalid character '%c' in expression.", c
);
1532 /* It's a name. See how long it is. */
1534 for
(c
= tokstart
[namelen
];
1535 (c
== '_' || c
== '$' ||
(c
>= '0' && c
<= '9')
1536 ||
(c
>= 'a' && c
<= 'z') ||
(c
>= 'A' && c
<= 'Z') || c
== '<');)
1541 while
(tokstart
[++i
] && tokstart
[i
] != '>');
1542 if
(tokstart
[i
] == '>')
1545 c
= tokstart
[++namelen
];
1548 /* The token "if" terminates the expression and is NOT
1549 removed from the input stream. */
1550 if
(namelen
== 2 && tokstart
[0] == 'i' && tokstart
[1] == 'f')
1559 /* Catch specific keywords. Should be done with a data structure. */
1563 if
(strncmp
(tokstart
, "unsigned", 8) == 0)
1565 if
(parse_language
->la_language
== language_cplus
1566 && strncmp
(tokstart
, "template", 8) == 0)
1568 if
(strncmp
(tokstart
, "volatile", 8) == 0)
1569 return VOLATILE_KEYWORD
;
1572 if
(strncmp
(tokstart
, "struct", 6) == 0)
1574 if
(strncmp
(tokstart
, "signed", 6) == 0)
1575 return SIGNED_KEYWORD
;
1576 if
(strncmp
(tokstart
, "sizeof", 6) == 0)
1578 if
(strncmp
(tokstart
, "double", 6) == 0)
1579 return DOUBLE_KEYWORD
;
1582 if
((parse_language
->la_language
== language_cplus
)
1583 && strncmp
(tokstart
, "class", 5) == 0)
1585 if
(strncmp
(tokstart
, "union", 5) == 0)
1587 if
(strncmp
(tokstart
, "short", 5) == 0)
1589 if
(strncmp
(tokstart
, "const", 5) == 0)
1590 return CONST_KEYWORD
;
1593 if
(strncmp
(tokstart
, "enum", 4) == 0)
1595 if
(strncmp
(tokstart
, "long", 4) == 0)
1599 if
(strncmp
(tokstart
, "int", 3) == 0)
1606 yylval.sval.ptr
= tokstart
;
1607 yylval.sval.length
= namelen
;
1609 if
(*tokstart
== '$')
1611 write_dollar_variable
(yylval.sval
);
1615 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1616 functions or symtabs. If this is not so, then ...
1617 Use token-type TYPENAME for symbols that happen to be defined
1618 currently as names of types; NAME for other symbols.
1619 The caller is not constrained to care about the distinction. */
1621 char *tmp
= copy_name
(yylval.sval
);
1623 int is_a_field_of_this
= 0, *need_this
;
1626 if
(parse_language
->la_language
== language_cplus ||
1627 parse_language
->la_language
== language_objc
)
1628 need_this
= &is_a_field_of_this
;
1630 need_this
= (int *) NULL
;
1632 sym
= lookup_symbol
(tmp
, expression_context_block
,
1635 /* Call lookup_symtab, not lookup_partial_symtab, in case there
1636 are no psymtabs (coff, xcoff, or some future change to blow
1637 away the psymtabs once symbols are read). */
1638 if
((sym
&& SYMBOL_CLASS
(sym
) == LOC_BLOCK
) ||
1639 lookup_symtab
(tmp
))
1641 yylval.ssym.sym
= sym
;
1642 yylval.ssym.is_a_field_of_this
= is_a_field_of_this
;
1645 if
(sym
&& SYMBOL_CLASS
(sym
) == LOC_TYPEDEF
)
1648 /* Despite the following flaw, we need to keep this code
1649 enabled. Because we can get called from
1650 check_stub_method, if we don't handle nested types then
1651 it screws many operations in any program which uses
1653 /* In "A::x", if x is a member function of A and there
1654 happens to be a type (nested or not, since the stabs
1655 don't make that distinction) named x, then this code
1656 incorrectly thinks we are dealing with nested types
1657 rather than a member function. */
1661 struct symbol
*best_sym
;
1663 /* Look ahead to detect nested types. This probably should
1664 be done in the grammar, but trying seemed to introduce a
1665 lot of shift/reduce and reduce/reduce conflicts. It's
1666 possible that it could be done, though. Or perhaps a
1667 non-grammar, but less ad hoc, approach would work well. */
1669 /* Since we do not currently have any way of distinguishing
1670 a nested type from a non-nested one (the stabs don't tell
1671 us whether a type is nested), we just ignore the
1678 /* Skip whitespace. */
1679 while
(*p
== ' ' ||
*p
== '\t' ||
*p
== '\n')
1681 if
(*p
== ':' && p
[1] == ':')
1683 /* Skip the `::'. */
1685 /* Skip whitespace. */
1686 while
(*p
== ' ' ||
*p
== '\t' ||
*p
== '\n')
1689 while
(*p
== '_' ||
*p
== '$' ||
(*p
>= '0' && *p
<= '9')
1690 ||
(*p
>= 'a' && *p
<= 'z')
1691 ||
(*p
>= 'A' && *p
<= 'Z'))
1695 struct symbol
*cur_sym
;
1696 /* As big as the whole rest of the expression,
1697 which is at least big enough. */
1698 char *ncopy
= alloca
(strlen
(tmp
) +
1699 strlen
(namestart
) + 3);
1703 memcpy
(tmp1
, tmp
, strlen
(tmp
));
1704 tmp1
+= strlen
(tmp
);
1705 memcpy
(tmp1
, "::", 2);
1707 memcpy
(tmp1
, namestart
, p
- namestart
);
1708 tmp1
[p
- namestart
] = '\0';
1709 cur_sym
= lookup_symbol
(ncopy
,
1710 expression_context_block
,
1711 VAR_DOMAIN
, (int *) NULL
);
1714 if
(SYMBOL_CLASS
(cur_sym
) == LOC_TYPEDEF
)
1732 yylval.tsym.type
= SYMBOL_TYPE
(best_sym
);
1734 yylval.tsym.type
= SYMBOL_TYPE
(sym
);
1739 = language_lookup_primitive_type_by_name
(parse_language
,
1740 parse_gdbarch
, tmp
);
1741 if
(yylval.tsym.type
!= NULL
)
1744 /* See if it's an ObjC classname. */
1747 CORE_ADDR Class
= lookup_objc_class
(tmp
);
1750 yylval.class.class
= Class
;
1751 if
((sym
= lookup_struct_typedef
(tmp
,
1752 expression_context_block
,
1754 yylval.class.type
= SYMBOL_TYPE
(sym
);
1759 /* Input names that aren't symbols but ARE valid hex numbers,
1760 when the input radix permits them, can be names or numbers
1761 depending on the parse. Note we support radixes > 16 here. */
1763 ((tokstart
[0] >= 'a' && tokstart
[0] < 'a' + input_radix
- 10) ||
1764 (tokstart
[0] >= 'A' && tokstart
[0] < 'A' + input_radix
- 10)))
1766 YYSTYPE newlval
; /* Its value is ignored. */
1767 hextype
= parse_number
(tokstart
, namelen
, 0, &newlval
);
1770 yylval.ssym.sym
= sym
;
1771 yylval.ssym.is_a_field_of_this
= is_a_field_of_this
;
1776 /* Any other kind of symbol. */
1777 yylval.ssym.sym
= sym
;
1778 yylval.ssym.is_a_field_of_this
= is_a_field_of_this
;
1787 if
(*lexptr
== '\0')
1788 error("A %s near end of expression.", (msg ? msg
: "error"));
1790 error ("A %s in expression, near `%s'.", (msg ? msg
: "error"),