1 /* YACC parser for C expressions, for GDB.
3 Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 2002, 2006, 2007, 2008
4 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 2 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, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
21 /* Parse a C expression from text in a string, and return the result
22 as a struct expression pointer. That structure contains arithmetic
23 operations in reverse polish, with constants represented by
24 operations that are followed by special data. See expression.h for
25 the details of the format. What is important here is that it can
26 be built up sequentially during the process of parsing; the lower
27 levels of the tree always come first in the result.
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
32 parser generator. Doing this with #defines and trying to control
33 the interaction with include files (<malloc.h> and <stdlib.h> for
34 example) just became too messy, particularly when such includes can
35 be inserted at random times by the parser generator. */
40 #include "gdb_string.h"
42 #include "expression.h"
44 #include "objc-lang.h" /* For objc language constructs. */
47 #include "parser-defs.h"
50 #include "bfd.h" /* Required by objfiles.h. */
51 #include "symfile.h" /* Required by objfiles.h. */
52 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
54 #include "completer.h" /* For skip_quoted(). */
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 (builtin_type_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 (builtin_type_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 (builtin_type_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 (builtin_type_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 (builtin_type_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);
719 write_exp_msymbol (msymbol,
720 lookup_function_type (builtin_type_int),
724 if (!have_full_symbols () && !have_partial_symbols ())
725 error ("No symbol table is loaded. Use the \"file\" command.");
727 error ("No symbol \"%s\" in current context.", name);
731 variable: name_not_typename
732 { struct symbol *sym = $1.sym;
736 if (symbol_read_needs_frame (sym))
738 if (innermost_block == 0 ||
739 contained_in (block_found,
741 innermost_block = block_found;
744 write_exp_elt_opcode (OP_VAR_VALUE);
745 /* We want to use the selected frame, not
746 another more inner frame which happens to
747 be in the same block. */
748 write_exp_elt_block (NULL);
749 write_exp_elt_sym (sym);
750 write_exp_elt_opcode (OP_VAR_VALUE);
752 else if ($1.is_a_field_of_this)
754 /* C++/ObjC: it hangs off of `this'/'self'.
755 Must not inadvertently convert from a
756 method call to data ref. */
757 if (innermost_block == 0 ||
758 contained_in (block_found, innermost_block))
759 innermost_block = block_found;
760 write_exp_elt_opcode (OP_OBJC_SELF);
761 write_exp_elt_opcode (OP_OBJC_SELF);
762 write_exp_elt_opcode (STRUCTOP_PTR);
763 write_exp_string ($1.stoken);
764 write_exp_elt_opcode (STRUCTOP_PTR);
768 struct minimal_symbol *msymbol;
769 char *arg = copy_name ($1.stoken);
772 lookup_minimal_symbol (arg, NULL, NULL);
775 write_exp_msymbol (msymbol,
776 lookup_function_type (builtin_type_int),
779 else if (!have_full_symbols () &&
780 !have_partial_symbols ())
781 error ("No symbol table is loaded. Use the \"file\" command.");
783 error ("No symbol \"%s\" in current context.",
784 copy_name ($1.stoken));
791 /* "const" and "volatile" are curently ignored. A type
792 qualifier before the type is currently handled in the
793 typebase rule. The reason for recognizing these here
794 (shift/reduce conflicts) might be obsolete now that some
795 pointer to member rules have been deleted. */
796 | typebase CONST_KEYWORD
797 | typebase VOLATILE_KEYWORD
799 { $$ = follow_types ($1); }
800 | typebase CONST_KEYWORD abs_decl
801 { $$ = follow_types ($1); }
802 | typebase VOLATILE_KEYWORD abs_decl
803 { $$ = follow_types ($1); }
807 { push_type (tp_pointer); $$ = 0; }
809 { push_type (tp_pointer); $$ = $2; }
811 { push_type (tp_reference); $$ = 0; }
813 { push_type (tp_reference); $$ = $2; }
817 direct_abs_decl: '(' abs_decl ')'
819 | direct_abs_decl array_mod
822 push_type (tp_array);
827 push_type (tp_array);
831 | direct_abs_decl func_mod
832 { push_type (tp_function); }
834 { push_type (tp_function); }
845 | '(' nonempty_typelist ')'
846 { free ($2); $$ = 0; }
849 /* We used to try to recognize more pointer to member types here, but
850 that didn't work (shift/reduce conflicts meant that these rules
851 never got executed). The problem is that
852 int (foo::bar::baz::bizzle)
853 is a function type but
854 int (foo::bar::baz::bizzle::*)
855 is a pointer to member type. Stroustrup loses again! */
860 typebase /* Implements (approximately): (type-qualifier)* type-specifier. */
866 error ("No symbol \"%s\" in current context.",
867 copy_name($1.stoken));
872 { $$ = builtin_type_int; }
874 { $$ = builtin_type_long; }
876 { $$ = builtin_type_short; }
878 { $$ = builtin_type_long; }
879 | UNSIGNED LONG INT_KEYWORD
880 { $$ = builtin_type_unsigned_long; }
882 { $$ = builtin_type_long_long; }
883 | LONG LONG INT_KEYWORD
884 { $$ = builtin_type_long_long; }
886 { $$ = builtin_type_unsigned_long_long; }
887 | UNSIGNED LONG LONG INT_KEYWORD
888 { $$ = builtin_type_unsigned_long_long; }
890 { $$ = builtin_type_short; }
891 | UNSIGNED SHORT INT_KEYWORD
892 { $$ = builtin_type_unsigned_short; }
894 { $$ = builtin_type_double; }
895 | LONG DOUBLE_KEYWORD
896 { $$ = builtin_type_long_double; }
898 { $$ = lookup_struct (copy_name ($2),
899 expression_context_block); }
901 { $$ = lookup_struct (copy_name ($2),
902 expression_context_block); }
904 { $$ = lookup_union (copy_name ($2),
905 expression_context_block); }
907 { $$ = lookup_enum (copy_name ($2),
908 expression_context_block); }
910 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
912 { $$ = builtin_type_unsigned_int; }
913 | SIGNED_KEYWORD typename
914 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
916 { $$ = builtin_type_int; }
917 | TEMPLATE name '<' type '>'
918 { $$ = lookup_template_type(copy_name($2), $4,
919 expression_context_block);
921 /* "const" and "volatile" are curently ignored. A type
922 qualifier after the type is handled in the ptype rule. I
923 think these could be too. */
924 | CONST_KEYWORD typebase { $$ = $2; }
925 | VOLATILE_KEYWORD typebase { $$ = $2; }
931 $$.stoken.ptr = "int";
932 $$.stoken.length = 3;
933 $$.type = builtin_type_int;
937 $$.stoken.ptr = "long";
938 $$.stoken.length = 4;
939 $$.type = builtin_type_long;
943 $$.stoken.ptr = "short";
944 $$.stoken.length = 5;
945 $$.type = builtin_type_short;
951 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
952 $<ivec>$[0] = 1; /* Number of types in vector. */
955 | nonempty_typelist ',' type
956 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
957 $$ = (struct type **) realloc ((char *) $1, len);
958 $$[$<ivec>$[0]] = $3;
962 name : NAME { $$ = $1.stoken; }
963 | BLOCKNAME { $$ = $1.stoken; }
964 | TYPENAME { $$ = $1.stoken; }
965 | CLASSNAME { $$ = $1.stoken; }
966 | NAME_OR_INT { $$ = $1.stoken; }
969 name_not_typename : NAME
971 /* These would be useful if name_not_typename was useful, but it is
972 just a fake for "variable", so these cause reduce/reduce conflicts
973 because the parser can't tell whether NAME_OR_INT is a
974 name_not_typename (=variable, =exp) or just an exp. If
975 name_not_typename was ever used in an lvalue context where only a
976 name could occur, this might be useful. */
982 /* Take care of parsing a number (anything that starts with a digit).
983 Set yylval and return the token type; update lexptr. LEN is the
984 number of characters in it. */
986 /*** Needs some error checking for the float case. ***/
989 parse_number (p, len, parsed_float, putithere)
995 /* FIXME: Shouldn't these be unsigned? We don't deal with negative
996 values here, and we do kind of silly things like cast to
1000 unsigned LONGEST un;
1004 int base = input_radix;
1007 /* Number of "L" suffixes encountered. */
1010 /* We have found a "L" or "U" suffix. */
1011 int found_suffix = 0;
1013 unsigned LONGEST high_bit;
1014 struct type *signed_type;
1015 struct type *unsigned_type;
1021 /* It's a float since it contains a point or an exponent. */
1023 sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c",
1024 &putithere->typed_val_float.dval, &c);
1026 /* See if it has `f' or `l' suffix (float or long double). */
1028 c = tolower (p[len - 1]);
1031 putithere->typed_val_float.type = builtin_type_float;
1033 putithere->typed_val_float.type = builtin_type_long_double;
1034 else if (isdigit (c) || c == '.')
1035 putithere->typed_val_float.type = builtin_type_double;
1042 /* Handle base-switching prefixes 0x, 0t, 0d, and 0. */
1076 if (c >= 'A' && c <= 'Z')
1078 if (c != 'l' && c != 'u')
1080 if (c >= '0' && c <= '9')
1088 if (base > 10 && c >= 'a' && c <= 'f')
1092 n += i = c - 'a' + 10;
1105 return ERROR; /* Char not a digit. */
1108 return ERROR; /* Invalid digit in this base. */
1110 /* Portably test for overflow (only works for nonzero values, so
1111 make a second check for zero). FIXME: Can't we just make n
1112 and prevn unsigned and avoid this? */
1113 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1114 unsigned_p = 1; /* Try something unsigned. */
1116 /* Portably test for unsigned overflow.
1117 FIXME: This check is wrong; for example it doesn't find
1118 overflow on 0x123456789 when LONGEST is 32 bits. */
1119 if (c != 'l' && c != 'u' && n != 0)
1121 if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1122 error ("Numeric constant too large.");
1127 /* An integer constant is an int, a long, or a long long. An L
1128 suffix forces it to be long; an LL suffix forces it to be long
1129 long. If not forced to a larger size, it gets the first type of
1130 the above that it fits in. To figure out whether it fits, we
1131 shift it right and see whether anything remains. Note that we
1132 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1133 operation, because many compilers will warn about such a shift
1134 (which always produces a zero result). Sometimes gdbarch_int_bit
1135 or gdbarch_long_int will be that big, sometimes not. To deal with
1136 the case where it is we just always shift the value more than
1137 once, with fewer bits each time. */
1139 un = (unsigned LONGEST)n >> 2;
1141 && (un >> (gdbarch_int_bit (current_gdbarch) - 2)) == 0)
1143 high_bit = ((unsigned LONGEST)1) << (gdbarch_int_bit (current_gdbarch) - 1);
1145 /* A large decimal (not hex or octal) constant (between INT_MAX
1146 and UINT_MAX) is a long or unsigned long, according to ANSI,
1147 never an unsigned int, but this code treats it as unsigned
1148 int. This probably should be fixed. GCC gives a warning on
1151 unsigned_type = builtin_type_unsigned_int;
1152 signed_type = builtin_type_int;
1154 else if (long_p <= 1
1155 && (un >> (gdbarch_long_bit (current_gdbarch) - 2)) == 0)
1157 high_bit = ((unsigned LONGEST)1) << (gdbarch_long_bit (current_gdbarch) - 1);
1158 unsigned_type = builtin_type_unsigned_long;
1159 signed_type = builtin_type_long;
1163 high_bit = (((unsigned LONGEST)1)
1164 << (gdbarch_long_long_bit (current_gdbarch) - 32 - 1)
1168 /* A long long does not fit in a LONGEST. */
1170 (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
1171 unsigned_type = builtin_type_unsigned_long_long;
1172 signed_type = builtin_type_long_long;
1175 putithere->typed_val_int.val = n;
1177 /* If the high bit of the worked out type is set then this number
1178 has to be unsigned. */
1180 if (unsigned_p || (n & high_bit))
1182 putithere->typed_val_int.type = unsigned_type;
1186 putithere->typed_val_int.type = signed_type;
1196 enum exp_opcode opcode;
1199 static const struct token tokentab3[] =
1201 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1202 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1205 static const struct token tokentab2[] =
1207 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1208 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1209 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1210 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1211 {"%=", ASSIGN_MODIFY, BINOP_REM},
1212 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1213 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1214 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1215 {"++", INCREMENT, BINOP_END},
1216 {"--", DECREMENT, BINOP_END},
1217 {"->", ARROW, BINOP_END},
1218 {"&&", ANDAND, BINOP_END},
1219 {"||", OROR, BINOP_END},
1220 {"::", COLONCOLON, BINOP_END},
1221 {"<<", LSH, BINOP_END},
1222 {">>", RSH, BINOP_END},
1223 {"==", EQUAL, BINOP_END},
1224 {"!=", NOTEQUAL, BINOP_END},
1225 {"<=", LEQ, BINOP_END},
1226 {">=", GEQ, BINOP_END}
1229 /* Read one token, getting characters through lexptr. */
1240 static char *tempbuf;
1241 static int tempbufsize;
1246 /* See if it is a special token of length 3. */
1247 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1248 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1251 yylval.opcode = tokentab3[i].opcode;
1252 return tokentab3[i].token;
1255 /* See if it is a special token of length 2. */
1256 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1257 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1260 yylval.opcode = tokentab2[i].opcode;
1261 return tokentab2[i].token;
1265 switch (tokchr = *tokstart)
1277 /* We either have a character constant ('0' or '\177' for
1278 example) or we have a quoted symbol reference ('foo(int,int)'
1279 in C++ for example). */
1283 c = parse_escape (&lexptr);
1285 error ("Empty character constant.");
1287 yylval.typed_val_int.val = c;
1288 yylval.typed_val_int.type = builtin_type_char;
1293 namelen = skip_quoted (tokstart) - tokstart;
1296 lexptr = tokstart + namelen;
1297 if (lexptr[-1] != '\'')
1298 error ("Unmatched single quote.");
1303 error ("Invalid character constant.");
1313 if (paren_depth == 0)
1320 if (comma_terminates && paren_depth == 0)
1326 /* Might be a floating point number. */
1327 if (lexptr[1] < '0' || lexptr[1] > '9')
1328 goto symbol; /* Nope, must be a symbol. */
1329 /* FALL THRU into number case. */
1342 /* It's a number. */
1343 int got_dot = 0, got_e = 0, toktype = FLOAT;
1344 /* Initialize toktype to anything other than ERROR. */
1346 int hex = input_radix > 10;
1347 int local_radix = input_radix;
1348 if (tokchr == '0' && (p[1] == 'x' || p[1] == 'X'))
1354 else if (tokchr == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1363 /* This test includes !hex because 'e' is a valid hex digit
1364 and thus does not indicate a floating point number when
1365 the radix is hex. */
1367 if (!hex && (*p == 'e' || *p == 'E'))
1369 toktype = ERROR; /* Only one 'e' in a float. */
1372 /* This test does not include !hex, because a '.' always
1373 indicates a decimal floating point number regardless of
1377 toktype = ERROR; /* Only one '.' in a float. */
1380 else if (got_e && (p[-1] == 'e' || p[-1] == 'E') &&
1381 (*p == '-' || *p == '+'))
1382 /* This is the sign of the exponent, not the end of the
1385 /* Always take decimal digits; parse_number handles radix
1387 else if (*p >= '0' && *p <= '9')
1389 /* We will take letters only if hex is true, and only up
1390 to what the input radix would permit. FSF was content
1391 to rely on parse_number to validate; but it leaks. */
1392 else if (*p >= 'a' && *p <= 'z')
1394 if (!hex || *p >= ('a' + local_radix - 10))
1397 else if (*p >= 'A' && *p <= 'Z')
1399 if (!hex || *p >= ('A' + local_radix - 10))
1404 if (toktype != ERROR)
1405 toktype = parse_number (tokstart, p - tokstart,
1406 got_dot | got_e, &yylval);
1407 if (toktype == ERROR)
1409 char *err_copy = (char *) alloca (p - tokstart + 1);
1411 memcpy (err_copy, tokstart, p - tokstart);
1412 err_copy[p - tokstart] = 0;
1413 error ("Invalid number \"%s\".", err_copy);
1430 case '@': /* Moved out below. */
1446 if (strncmp(tokstart, "@selector", 9) == 0)
1448 tokptr = strchr(tokstart, '(');
1451 error ("Missing '(' in @selector(...)");
1454 tokptr++; /* Skip the '('. */
1456 /* Grow the static temp buffer if necessary, including
1457 allocating the first one on demand. */
1458 if (tempbufindex + 1 >= tempbufsize)
1460 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1462 tempbuf[tempbufindex++] = *tokptr++;
1463 } while ((*tokptr != ')') && (*tokptr != '\0'));
1464 if (*tokptr++ != ')')
1466 error ("Missing ')' in @selector(...)");
1468 tempbuf[tempbufindex] = '\0';
1469 yylval.sval.ptr = tempbuf;
1470 yylval.sval.length = tempbufindex;
1474 if (tokstart[1] != '"')
1479 /* ObjC NextStep NSString constant: fall thru and parse like
1485 /* Build the gdb internal form of the input string in tempbuf,
1486 translating any standard C escape forms seen. Note that the
1487 buffer is null byte terminated *only* for the convenience of
1488 debugging gdb itself and printing the buffer contents when
1489 the buffer contains no embedded nulls. Gdb does not depend
1490 upon the buffer being null byte terminated, it uses the
1491 length string instead. This allows gdb to handle C strings
1492 (as well as strings in other languages) with embedded null
1495 tokptr = ++tokstart;
1499 /* Grow the static temp buffer if necessary, including
1500 allocating the first one on demand. */
1501 if (tempbufindex + 1 >= tempbufsize)
1503 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1509 /* Do nothing, loop will terminate. */
1513 c = parse_escape (&tokptr);
1518 tempbuf[tempbufindex++] = c;
1521 tempbuf[tempbufindex++] = *tokptr++;
1524 } while ((*tokptr != '"') && (*tokptr != '\0'));
1525 if (*tokptr++ != '"')
1527 error ("Unterminated string in expression.");
1529 tempbuf[tempbufindex] = '\0'; /* See note above. */
1530 yylval.sval.ptr = tempbuf;
1531 yylval.sval.length = tempbufindex;
1533 return (tokchr == '@' ? NSSTRING : STRING);
1536 if (!(tokchr == '_' || tokchr == '$' ||
1537 (tokchr >= 'a' && tokchr <= 'z') || (tokchr >= 'A' && tokchr <= 'Z')))
1538 /* We must have come across a bad character (e.g. ';'). */
1539 error ("Invalid character '%c' in expression.", c);
1541 /* It's a name. See how long it is. */
1543 for (c = tokstart[namelen];
1544 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1545 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1550 while (tokstart[++i] && tokstart[i] != '>');
1551 if (tokstart[i] == '>')
1554 c = tokstart[++namelen];
1557 /* The token "if" terminates the expression and is NOT
1558 removed from the input stream. */
1559 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1568 /* Catch specific keywords. Should be done with a data structure. */
1572 if (strncmp (tokstart, "unsigned", 8) == 0)
1574 if (current_language->la_language == language_cplus
1575 && strncmp (tokstart, "template", 8) == 0)
1577 if (strncmp (tokstart, "volatile", 8) == 0)
1578 return VOLATILE_KEYWORD;
1581 if (strncmp (tokstart, "struct", 6) == 0)
1583 if (strncmp (tokstart, "signed", 6) == 0)
1584 return SIGNED_KEYWORD;
1585 if (strncmp (tokstart, "sizeof", 6) == 0)
1587 if (strncmp (tokstart, "double", 6) == 0)
1588 return DOUBLE_KEYWORD;
1591 if ((current_language->la_language == language_cplus)
1592 && strncmp (tokstart, "class", 5) == 0)
1594 if (strncmp (tokstart, "union", 5) == 0)
1596 if (strncmp (tokstart, "short", 5) == 0)
1598 if (strncmp (tokstart, "const", 5) == 0)
1599 return CONST_KEYWORD;
1602 if (strncmp (tokstart, "enum", 4) == 0)
1604 if (strncmp (tokstart, "long", 4) == 0)
1608 if (strncmp (tokstart, "int", 3) == 0)
1615 yylval.sval.ptr = tokstart;
1616 yylval.sval.length = namelen;
1618 if (*tokstart == '$')
1620 write_dollar_variable (yylval.sval);
1624 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1625 functions or symtabs. If this is not so, then ...
1626 Use token-type TYPENAME for symbols that happen to be defined
1627 currently as names of types; NAME for other symbols.
1628 The caller is not constrained to care about the distinction. */
1630 char *tmp = copy_name (yylval.sval);
1632 int is_a_field_of_this = 0, *need_this;
1635 if (current_language->la_language == language_cplus ||
1636 current_language->la_language == language_objc)
1637 need_this = &is_a_field_of_this;
1639 need_this = (int *) NULL;
1641 sym = lookup_symbol (tmp, expression_context_block,
1644 /* Call lookup_symtab, not lookup_partial_symtab, in case there
1645 are no psymtabs (coff, xcoff, or some future change to blow
1646 away the psymtabs once symbols are read). */
1647 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1648 lookup_symtab (tmp))
1650 yylval.ssym.sym = sym;
1651 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1654 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1657 /* Despite the following flaw, we need to keep this code
1658 enabled. Because we can get called from
1659 check_stub_method, if we don't handle nested types then
1660 it screws many operations in any program which uses
1662 /* In "A::x", if x is a member function of A and there
1663 happens to be a type (nested or not, since the stabs
1664 don't make that distinction) named x, then this code
1665 incorrectly thinks we are dealing with nested types
1666 rather than a member function. */
1670 struct symbol *best_sym;
1672 /* Look ahead to detect nested types. This probably should
1673 be done in the grammar, but trying seemed to introduce a
1674 lot of shift/reduce and reduce/reduce conflicts. It's
1675 possible that it could be done, though. Or perhaps a
1676 non-grammar, but less ad hoc, approach would work well. */
1678 /* Since we do not currently have any way of distinguishing
1679 a nested type from a non-nested one (the stabs don't tell
1680 us whether a type is nested), we just ignore the
1687 /* Skip whitespace. */
1688 while (*p == ' ' || *p == '\t' || *p == '\n')
1690 if (*p == ':' && p[1] == ':')
1692 /* Skip the `::'. */
1694 /* Skip whitespace. */
1695 while (*p == ' ' || *p == '\t' || *p == '\n')
1698 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1699 || (*p >= 'a' && *p <= 'z')
1700 || (*p >= 'A' && *p <= 'Z'))
1704 struct symbol *cur_sym;
1705 /* As big as the whole rest of the expression,
1706 which is at least big enough. */
1707 char *ncopy = alloca (strlen (tmp) +
1708 strlen (namestart) + 3);
1712 memcpy (tmp1, tmp, strlen (tmp));
1713 tmp1 += strlen (tmp);
1714 memcpy (tmp1, "::", 2);
1716 memcpy (tmp1, namestart, p - namestart);
1717 tmp1[p - namestart] = '\0';
1718 cur_sym = lookup_symbol (ncopy,
1719 expression_context_block,
1720 VAR_DOMAIN, (int *) NULL);
1723 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1741 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1743 yylval.tsym.type = SYMBOL_TYPE (sym);
1748 = language_lookup_primitive_type_by_name (current_language,
1749 current_gdbarch, tmp);
1750 if (yylval.tsym.type != NULL)
1753 /* See if it's an ObjC classname. */
1756 CORE_ADDR Class = lookup_objc_class(tmp);
1759 yylval.class.class = Class;
1760 if ((sym = lookup_struct_typedef (tmp,
1761 expression_context_block,
1763 yylval.class.type = SYMBOL_TYPE (sym);
1768 /* Input names that aren't symbols but ARE valid hex numbers,
1769 when the input radix permits them, can be names or numbers
1770 depending on the parse. Note we support radixes > 16 here. */
1772 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1773 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1775 YYSTYPE newlval; /* Its value is ignored. */
1776 hextype = parse_number (tokstart, namelen, 0, &newlval);
1779 yylval.ssym.sym = sym;
1780 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1785 /* Any other kind of symbol. */
1786 yylval.ssym.sym = sym;
1787 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1796 if (*lexptr == '\0')
1797 error("A %s near end of expression.", (msg ? msg : "error"));
1799 error ("A %s in expression, near `%s'.", (msg ? msg : "error"),