1 /* YACC parser for C expressions, for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* Parse a C expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result.
31 Note that malloc's and realloc's in this file are transformed to
32 xmalloc and xrealloc respectively by the same sed command in the
33 makefile that remaps any other malloc/realloc inserted by the parser
34 generator. Doing this with #defines and trying to control the interaction
35 with include files (<malloc.h> and <stdlib.h> for example) just became
36 too messy, particularly when such includes can be inserted at random
37 times by the parser generator. */
42 #include "gdb_string.h"
44 #include "expression.h"
46 #include "parser-defs.h"
49 #include "bfd.h" /* Required by objfiles.h. */
50 #include "symfile.h" /* Required by objfiles.h. */
51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
53 /* Flag indicating we're dealing with HP-compiled objects */
54 extern int hp_som_som_object_present;
56 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
57 as well as gratuitiously global symbol names, so we can have multiple
58 yacc generated parsers in gdb. Note that these are only the variables
59 produced by yacc. If other parser generators (bison, byacc, etc) produce
60 additional global names that conflict at link time, then those parser
61 generators need to be fixed instead of adding those names to this list. */
63 #define yymaxdepth c_maxdepth
64 #define yyparse c_parse
66 #define yyerror c_error
69 #define yydebug c_debug
78 #define yyerrflag c_errflag
79 #define yynerrs c_nerrs
84 #define yystate c_state
90 #define yyreds c_reds /* With YYDEBUG defined */
91 #define yytoks c_toks /* With YYDEBUG defined */
94 #define yydefred c_yydefred
95 #define yydgoto c_yydgoto
96 #define yysindex c_yysindex
97 #define yyrindex c_yyrindex
98 #define yygindex c_yygindex
99 #define yytable c_yytable
100 #define yycheck c_yycheck
103 #define YYDEBUG 0 /* Default to no yydebug support */
108 static int yylex (void);
110 void yyerror (char *);
114 /* Although the yacc "value" of an expression is not used,
115 since the result is stored in the structure being created,
116 other node types do have values. */
133 struct symtoken ssym;
136 enum exp_opcode opcode;
137 struct internalvar *ivar;
144 /* YYSTYPE gets defined by %union */
145 static int parse_number (char *, int, int, YYSTYPE *);
148 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
150 %type <tval> type typebase
151 %type <tvec> nonempty_typelist
152 /* %type <bval> block */
154 /* Fancy type parsing. */
155 %type <voidval> func_mod direct_abs_decl abs_decl
157 %type <lval> array_mod
159 %token <typed_val_int> INT
160 %token <typed_val_float> FLOAT
162 /* Both NAME and TYPENAME tokens represent symbols in the input,
163 and both convey their data as strings.
164 But a TYPENAME is a string that happens to be defined as a typedef
165 or builtin type name (such as int or char)
166 and a NAME is any other symbol.
167 Contexts where this distinction is not important can use the
168 nonterminal "name", which matches either NAME or TYPENAME. */
171 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
172 %token <tsym> TYPENAME
174 %type <ssym> name_not_typename
175 %type <tsym> typename
177 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
178 but which would parse as a valid number in the current input radix.
179 E.g. "c" when input_radix==16. Depending on the parse, it will be
180 turned into a name or into a number. */
182 %token <ssym> NAME_OR_INT
184 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
188 /* Special type cases, put in to allow the parser to distinguish different
190 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
192 %token <voidval> VARIABLE
194 %token <opcode> ASSIGN_MODIFY
204 %right '=' ASSIGN_MODIFY
212 %left '<' '>' LEQ GEQ
217 %right UNARY INCREMENT DECREMENT
218 %right ARROW '.' '[' '('
219 %token <ssym> BLOCKNAME
220 %token <bval> FILENAME
232 { write_exp_elt_opcode(OP_TYPE);
233 write_exp_elt_type($1);
234 write_exp_elt_opcode(OP_TYPE);}
237 /* Expressions, including the comma operator. */
240 { write_exp_elt_opcode (BINOP_COMMA); }
243 /* Expressions, not including the comma operator. */
244 exp : '*' exp %prec UNARY
245 { write_exp_elt_opcode (UNOP_IND); }
247 exp : '&' exp %prec UNARY
248 { write_exp_elt_opcode (UNOP_ADDR); }
250 exp : '-' exp %prec UNARY
251 { write_exp_elt_opcode (UNOP_NEG); }
254 exp : '!' exp %prec UNARY
255 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
258 exp : '~' exp %prec UNARY
259 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
262 exp : INCREMENT exp %prec UNARY
263 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
266 exp : DECREMENT exp %prec UNARY
267 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
270 exp : exp INCREMENT %prec UNARY
271 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
274 exp : exp DECREMENT %prec UNARY
275 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
278 exp : SIZEOF exp %prec UNARY
279 { write_exp_elt_opcode (UNOP_SIZEOF); }
283 { write_exp_elt_opcode (STRUCTOP_PTR);
284 write_exp_string ($3);
285 write_exp_elt_opcode (STRUCTOP_PTR); }
288 exp : exp ARROW qualified_name
289 { /* exp->type::name becomes exp->*(&type::name) */
290 /* Note: this doesn't work if name is a
291 static member! FIXME */
292 write_exp_elt_opcode (UNOP_ADDR);
293 write_exp_elt_opcode (STRUCTOP_MPTR); }
296 exp : exp ARROW '*' exp
297 { write_exp_elt_opcode (STRUCTOP_MPTR); }
301 { write_exp_elt_opcode (STRUCTOP_STRUCT);
302 write_exp_string ($3);
303 write_exp_elt_opcode (STRUCTOP_STRUCT); }
306 exp : exp '.' qualified_name
307 { /* exp.type::name becomes exp.*(&type::name) */
308 /* Note: this doesn't work if name is a
309 static member! FIXME */
310 write_exp_elt_opcode (UNOP_ADDR);
311 write_exp_elt_opcode (STRUCTOP_MEMBER); }
314 exp : exp '.' '*' exp
315 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
318 exp : exp '[' exp1 ']'
319 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
323 /* This is to save the value of arglist_len
324 being accumulated by an outer function call. */
325 { start_arglist (); }
326 arglist ')' %prec ARROW
327 { write_exp_elt_opcode (OP_FUNCALL);
328 write_exp_elt_longcst ((LONGEST) end_arglist ());
329 write_exp_elt_opcode (OP_FUNCALL); }
333 { start_arglist (); }
343 arglist : arglist ',' exp %prec ABOVE_COMMA
348 { $$ = end_arglist () - 1; }
350 exp : lcurly arglist rcurly %prec ARROW
351 { write_exp_elt_opcode (OP_ARRAY);
352 write_exp_elt_longcst ((LONGEST) 0);
353 write_exp_elt_longcst ((LONGEST) $3);
354 write_exp_elt_opcode (OP_ARRAY); }
357 exp : lcurly type rcurly exp %prec UNARY
358 { write_exp_elt_opcode (UNOP_MEMVAL);
359 write_exp_elt_type ($2);
360 write_exp_elt_opcode (UNOP_MEMVAL); }
363 exp : '(' type ')' exp %prec UNARY
364 { write_exp_elt_opcode (UNOP_CAST);
365 write_exp_elt_type ($2);
366 write_exp_elt_opcode (UNOP_CAST); }
373 /* Binary operators in order of decreasing precedence. */
376 { write_exp_elt_opcode (BINOP_REPEAT); }
380 { write_exp_elt_opcode (BINOP_MUL); }
384 { write_exp_elt_opcode (BINOP_DIV); }
388 { write_exp_elt_opcode (BINOP_REM); }
392 { write_exp_elt_opcode (BINOP_ADD); }
396 { write_exp_elt_opcode (BINOP_SUB); }
400 { write_exp_elt_opcode (BINOP_LSH); }
404 { write_exp_elt_opcode (BINOP_RSH); }
408 { write_exp_elt_opcode (BINOP_EQUAL); }
411 exp : exp NOTEQUAL exp
412 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
416 { write_exp_elt_opcode (BINOP_LEQ); }
420 { write_exp_elt_opcode (BINOP_GEQ); }
424 { write_exp_elt_opcode (BINOP_LESS); }
428 { write_exp_elt_opcode (BINOP_GTR); }
432 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
436 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
440 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
444 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
448 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
451 exp : exp '?' exp ':' exp %prec '?'
452 { write_exp_elt_opcode (TERNOP_COND); }
456 { write_exp_elt_opcode (BINOP_ASSIGN); }
459 exp : exp ASSIGN_MODIFY exp
460 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
461 write_exp_elt_opcode ($2);
462 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
466 { write_exp_elt_opcode (OP_LONG);
467 write_exp_elt_type ($1.type);
468 write_exp_elt_longcst ((LONGEST)($1.val));
469 write_exp_elt_opcode (OP_LONG); }
474 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
475 write_exp_elt_opcode (OP_LONG);
476 write_exp_elt_type (val.typed_val_int.type);
477 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
478 write_exp_elt_opcode (OP_LONG);
484 { write_exp_elt_opcode (OP_DOUBLE);
485 write_exp_elt_type ($1.type);
486 write_exp_elt_dblcst ($1.dval);
487 write_exp_elt_opcode (OP_DOUBLE); }
494 /* Already written by write_dollar_variable. */
497 exp : SIZEOF '(' type ')' %prec UNARY
498 { write_exp_elt_opcode (OP_LONG);
499 write_exp_elt_type (builtin_type_int);
501 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
502 write_exp_elt_opcode (OP_LONG); }
506 { /* C strings are converted into array constants with
507 an explicit null byte added at the end. Thus
508 the array upper bound is the string length.
509 There is no such thing in C as a completely empty
511 char *sp = $1.ptr; int count = $1.length;
514 write_exp_elt_opcode (OP_LONG);
515 write_exp_elt_type (builtin_type_char);
516 write_exp_elt_longcst ((LONGEST)(*sp++));
517 write_exp_elt_opcode (OP_LONG);
519 write_exp_elt_opcode (OP_LONG);
520 write_exp_elt_type (builtin_type_char);
521 write_exp_elt_longcst ((LONGEST)'\0');
522 write_exp_elt_opcode (OP_LONG);
523 write_exp_elt_opcode (OP_ARRAY);
524 write_exp_elt_longcst ((LONGEST) 0);
525 write_exp_elt_longcst ((LONGEST) ($1.length));
526 write_exp_elt_opcode (OP_ARRAY); }
531 { write_exp_elt_opcode (OP_THIS);
532 write_exp_elt_opcode (OP_THIS); }
536 { write_exp_elt_opcode (OP_LONG);
537 write_exp_elt_type (builtin_type_bool);
538 write_exp_elt_longcst ((LONGEST) 1);
539 write_exp_elt_opcode (OP_LONG); }
543 { write_exp_elt_opcode (OP_LONG);
544 write_exp_elt_type (builtin_type_bool);
545 write_exp_elt_longcst ((LONGEST) 0);
546 write_exp_elt_opcode (OP_LONG); }
554 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
556 error ("No file or function \"%s\".",
557 copy_name ($1.stoken));
565 block : block COLONCOLON name
567 = lookup_symbol (copy_name ($3), $1,
568 VAR_NAMESPACE, (int *) NULL,
569 (struct symtab **) NULL);
570 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
571 error ("No function \"%s\" in specified context.",
573 $$ = SYMBOL_BLOCK_VALUE (tem); }
576 variable: block COLONCOLON name
577 { struct symbol *sym;
578 sym = lookup_symbol (copy_name ($3), $1,
579 VAR_NAMESPACE, (int *) NULL,
580 (struct symtab **) NULL);
582 error ("No symbol \"%s\" in specified context.",
585 write_exp_elt_opcode (OP_VAR_VALUE);
586 /* block_found is set by lookup_symbol. */
587 write_exp_elt_block (block_found);
588 write_exp_elt_sym (sym);
589 write_exp_elt_opcode (OP_VAR_VALUE); }
592 qualified_name: typebase COLONCOLON name
594 struct type *type = $1;
595 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
596 && TYPE_CODE (type) != TYPE_CODE_UNION)
597 error ("`%s' is not defined as an aggregate type.",
600 write_exp_elt_opcode (OP_SCOPE);
601 write_exp_elt_type (type);
602 write_exp_string ($3);
603 write_exp_elt_opcode (OP_SCOPE);
605 | typebase COLONCOLON '~' name
607 struct type *type = $1;
608 struct stoken tmp_token;
609 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
610 && TYPE_CODE (type) != TYPE_CODE_UNION)
611 error ("`%s' is not defined as an aggregate type.",
614 tmp_token.ptr = (char*) alloca ($4.length + 2);
615 tmp_token.length = $4.length + 1;
616 tmp_token.ptr[0] = '~';
617 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
618 tmp_token.ptr[tmp_token.length] = 0;
620 /* Check for valid destructor name. */
621 destructor_name_p (tmp_token.ptr, type);
622 write_exp_elt_opcode (OP_SCOPE);
623 write_exp_elt_type (type);
624 write_exp_string (tmp_token);
625 write_exp_elt_opcode (OP_SCOPE);
629 variable: qualified_name
632 char *name = copy_name ($2);
634 struct minimal_symbol *msymbol;
637 lookup_symbol (name, (const struct block *) NULL,
638 VAR_NAMESPACE, (int *) NULL,
639 (struct symtab **) NULL);
642 write_exp_elt_opcode (OP_VAR_VALUE);
643 write_exp_elt_block (NULL);
644 write_exp_elt_sym (sym);
645 write_exp_elt_opcode (OP_VAR_VALUE);
649 msymbol = lookup_minimal_symbol (name, NULL, NULL);
652 write_exp_msymbol (msymbol,
653 lookup_function_type (builtin_type_int),
657 if (!have_full_symbols () && !have_partial_symbols ())
658 error ("No symbol table is loaded. Use the \"file\" command.");
660 error ("No symbol \"%s\" in current context.", name);
664 variable: name_not_typename
665 { struct symbol *sym = $1.sym;
669 if (symbol_read_needs_frame (sym))
671 if (innermost_block == 0 ||
672 contained_in (block_found,
674 innermost_block = block_found;
677 write_exp_elt_opcode (OP_VAR_VALUE);
678 /* We want to use the selected frame, not
679 another more inner frame which happens to
680 be in the same block. */
681 write_exp_elt_block (NULL);
682 write_exp_elt_sym (sym);
683 write_exp_elt_opcode (OP_VAR_VALUE);
685 else if ($1.is_a_field_of_this)
687 /* C++: it hangs off of `this'. Must
688 not inadvertently convert from a method call
690 if (innermost_block == 0 ||
691 contained_in (block_found, innermost_block))
692 innermost_block = block_found;
693 write_exp_elt_opcode (OP_THIS);
694 write_exp_elt_opcode (OP_THIS);
695 write_exp_elt_opcode (STRUCTOP_PTR);
696 write_exp_string ($1.stoken);
697 write_exp_elt_opcode (STRUCTOP_PTR);
701 struct minimal_symbol *msymbol;
702 register char *arg = copy_name ($1.stoken);
705 lookup_minimal_symbol (arg, NULL, NULL);
708 write_exp_msymbol (msymbol,
709 lookup_function_type (builtin_type_int),
712 else if (!have_full_symbols () && !have_partial_symbols ())
713 error ("No symbol table is loaded. Use the \"file\" command.");
715 error ("No symbol \"%s\" in current context.",
716 copy_name ($1.stoken));
721 space_identifier : '@' NAME
722 { push_type_address_space (copy_name ($2.stoken));
723 push_type (tp_space_identifier);
727 const_or_volatile: const_or_volatile_noopt
731 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
734 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
735 | const_or_volatile_noopt
738 const_or_volatile_or_space_identifier:
739 const_or_volatile_or_space_identifier_noopt
744 { push_type (tp_pointer); $$ = 0; }
746 { push_type (tp_pointer); $$ = $2; }
748 { push_type (tp_reference); $$ = 0; }
750 { push_type (tp_reference); $$ = $2; }
754 direct_abs_decl: '(' abs_decl ')'
756 | direct_abs_decl array_mod
759 push_type (tp_array);
764 push_type (tp_array);
768 | direct_abs_decl func_mod
769 { push_type (tp_function); }
771 { push_type (tp_function); }
782 | '(' nonempty_typelist ')'
783 { free ((PTR)$2); $$ = 0; }
786 /* We used to try to recognize more pointer to member types here, but
787 that didn't work (shift/reduce conflicts meant that these rules never
788 got executed). The problem is that
789 int (foo::bar::baz::bizzle)
790 is a function type but
791 int (foo::bar::baz::bizzle::*)
792 is a pointer to member type. Stroustrup loses again! */
795 | typebase COLONCOLON '*'
796 { $$ = lookup_member_type (builtin_type_int, $1); }
799 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
803 { $$ = builtin_type_int; }
805 { $$ = builtin_type_long; }
807 { $$ = builtin_type_short; }
809 { $$ = builtin_type_long; }
810 | LONG SIGNED_KEYWORD INT_KEYWORD
811 { $$ = builtin_type_long; }
812 | LONG SIGNED_KEYWORD
813 { $$ = builtin_type_long; }
814 | SIGNED_KEYWORD LONG INT_KEYWORD
815 { $$ = builtin_type_long; }
816 | UNSIGNED LONG INT_KEYWORD
817 { $$ = builtin_type_unsigned_long; }
818 | LONG UNSIGNED INT_KEYWORD
819 { $$ = builtin_type_unsigned_long; }
821 { $$ = builtin_type_unsigned_long; }
823 { $$ = builtin_type_long_long; }
824 | LONG LONG INT_KEYWORD
825 { $$ = builtin_type_long_long; }
826 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
827 { $$ = builtin_type_long_long; }
828 | LONG LONG SIGNED_KEYWORD
829 { $$ = builtin_type_long_long; }
830 | SIGNED_KEYWORD LONG LONG
831 { $$ = builtin_type_long_long; }
833 { $$ = builtin_type_unsigned_long_long; }
834 | UNSIGNED LONG LONG INT_KEYWORD
835 { $$ = builtin_type_unsigned_long_long; }
837 { $$ = builtin_type_unsigned_long_long; }
838 | LONG LONG UNSIGNED INT_KEYWORD
839 { $$ = builtin_type_unsigned_long_long; }
840 | SIGNED_KEYWORD LONG LONG
841 { $$ = lookup_signed_typename ("long long"); }
842 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
843 { $$ = lookup_signed_typename ("long long"); }
845 { $$ = builtin_type_short; }
846 | SHORT SIGNED_KEYWORD INT_KEYWORD
847 { $$ = builtin_type_short; }
848 | SHORT SIGNED_KEYWORD
849 { $$ = builtin_type_short; }
850 | UNSIGNED SHORT INT_KEYWORD
851 { $$ = builtin_type_unsigned_short; }
853 { $$ = builtin_type_unsigned_short; }
854 | SHORT UNSIGNED INT_KEYWORD
855 { $$ = builtin_type_unsigned_short; }
857 { $$ = builtin_type_double; }
858 | LONG DOUBLE_KEYWORD
859 { $$ = builtin_type_long_double; }
861 { $$ = lookup_struct (copy_name ($2),
862 expression_context_block); }
864 { $$ = lookup_struct (copy_name ($2),
865 expression_context_block); }
867 { $$ = lookup_union (copy_name ($2),
868 expression_context_block); }
870 { $$ = lookup_enum (copy_name ($2),
871 expression_context_block); }
873 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
875 { $$ = builtin_type_unsigned_int; }
876 | SIGNED_KEYWORD typename
877 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
879 { $$ = builtin_type_int; }
880 /* It appears that this rule for templates is never
881 reduced; template recognition happens by lookahead
882 in the token processing code in yylex. */
883 | TEMPLATE name '<' type '>'
884 { $$ = lookup_template_type(copy_name($2), $4,
885 expression_context_block);
887 | const_or_volatile_or_space_identifier_noopt typebase
888 { $$ = follow_types ($2); }
889 | typebase const_or_volatile_or_space_identifier_noopt
890 { $$ = follow_types ($1); }
896 $$.stoken.ptr = "int";
897 $$.stoken.length = 3;
898 $$.type = builtin_type_int;
902 $$.stoken.ptr = "long";
903 $$.stoken.length = 4;
904 $$.type = builtin_type_long;
908 $$.stoken.ptr = "short";
909 $$.stoken.length = 5;
910 $$.type = builtin_type_short;
916 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
917 $<ivec>$[0] = 1; /* Number of types in vector */
920 | nonempty_typelist ',' type
921 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
922 $$ = (struct type **) realloc ((char *) $1, len);
923 $$[$<ivec>$[0]] = $3;
928 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
929 { $$ = follow_types ($1); }
932 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
933 | VOLATILE_KEYWORD CONST_KEYWORD
936 const_or_volatile_noopt: const_and_volatile
937 { push_type (tp_const);
938 push_type (tp_volatile);
941 { push_type (tp_const); }
943 { push_type (tp_volatile); }
946 name : NAME { $$ = $1.stoken; }
947 | BLOCKNAME { $$ = $1.stoken; }
948 | TYPENAME { $$ = $1.stoken; }
949 | NAME_OR_INT { $$ = $1.stoken; }
952 name_not_typename : NAME
954 /* These would be useful if name_not_typename was useful, but it is just
955 a fake for "variable", so these cause reduce/reduce conflicts because
956 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
957 =exp) or just an exp. If name_not_typename was ever used in an lvalue
958 context where only a name could occur, this might be useful.
965 /* Take care of parsing a number (anything that starts with a digit).
966 Set yylval and return the token type; update lexptr.
967 LEN is the number of characters in it. */
969 /*** Needs some error checking for the float case ***/
972 parse_number (p, len, parsed_float, putithere)
978 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
979 here, and we do kind of silly things like cast to unsigned. */
980 register LONGEST n = 0;
981 register LONGEST prevn = 0;
986 register int base = input_radix;
989 /* Number of "L" suffixes encountered. */
992 /* We have found a "L" or "U" suffix. */
993 int found_suffix = 0;
996 struct type *signed_type;
997 struct type *unsigned_type;
1001 /* It's a float since it contains a point or an exponent. */
1003 int num = 0; /* number of tokens scanned by scanf */
1004 char saved_char = p[len];
1006 p[len] = 0; /* null-terminate the token */
1007 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
1008 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
1009 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
1010 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
1013 #ifdef SCANF_HAS_LONG_DOUBLE
1014 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
1016 /* Scan it into a double, then assign it to the long double.
1017 This at least wins with values representable in the range
1020 num = sscanf (p, "%lg%c", &temp,&c);
1021 putithere->typed_val_float.dval = temp;
1024 p[len] = saved_char; /* restore the input stream */
1025 if (num != 1) /* check scanf found ONLY a float ... */
1027 /* See if it has `f' or `l' suffix (float or long double). */
1029 c = tolower (p[len - 1]);
1032 putithere->typed_val_float.type = builtin_type_float;
1034 putithere->typed_val_float.type = builtin_type_long_double;
1035 else if (isdigit (c) || c == '.')
1036 putithere->typed_val_float.type = builtin_type_double;
1043 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1077 if (c >= 'A' && c <= 'Z')
1079 if (c != 'l' && c != 'u')
1081 if (c >= '0' && c <= '9')
1089 if (base > 10 && c >= 'a' && c <= 'f')
1093 n += i = c - 'a' + 10;
1106 return ERROR; /* Char not a digit */
1109 return ERROR; /* Invalid digit in this base */
1111 /* Portably test for overflow (only works for nonzero values, so make
1112 a second check for zero). FIXME: Can't we just make n and prevn
1113 unsigned and avoid this? */
1114 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1115 unsigned_p = 1; /* Try something unsigned */
1117 /* Portably test for unsigned overflow.
1118 FIXME: This check is wrong; for example it doesn't find overflow
1119 on 0x123456789 when LONGEST is 32 bits. */
1120 if (c != 'l' && c != 'u' && n != 0)
1122 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1123 error ("Numeric constant too large.");
1128 /* An integer constant is an int, a long, or a long long. An L
1129 suffix forces it to be long; an LL suffix forces it to be long
1130 long. If not forced to a larger size, it gets the first type of
1131 the above that it fits in. To figure out whether it fits, we
1132 shift it right and see whether anything remains. Note that we
1133 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1134 operation, because many compilers will warn about such a shift
1135 (which always produces a zero result). Sometimes TARGET_INT_BIT
1136 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
1137 the case where it is we just always shift the value more than
1138 once, with fewer bits each time. */
1140 un = (ULONGEST)n >> 2;
1142 && (un >> (TARGET_INT_BIT - 2)) == 0)
1144 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
1146 /* A large decimal (not hex or octal) constant (between INT_MAX
1147 and UINT_MAX) is a long or unsigned long, according to ANSI,
1148 never an unsigned int, but this code treats it as unsigned
1149 int. This probably should be fixed. GCC gives a warning on
1152 unsigned_type = builtin_type_unsigned_int;
1153 signed_type = builtin_type_int;
1155 else if (long_p <= 1
1156 && (un >> (TARGET_LONG_BIT - 2)) == 0)
1158 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
1159 unsigned_type = builtin_type_unsigned_long;
1160 signed_type = builtin_type_long;
1165 if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
1166 /* A long long does not fit in a LONGEST. */
1167 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1169 shift = (TARGET_LONG_LONG_BIT - 1);
1170 high_bit = (ULONGEST) 1 << shift;
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;
1242 struct symbol * sym_class = NULL;
1243 char * token_string = NULL;
1244 int class_prefix = 0;
1249 /* Check if this is a macro invocation that we need to expand. */
1250 if (! scanning_macro_expansion ())
1252 char *expanded = macro_expand_next (&lexptr,
1253 expression_macro_lookup_func,
1254 expression_macro_lookup_baton);
1257 scan_macro_expansion (expanded);
1260 prev_lexptr = lexptr;
1264 /* See if it is a special token of length 3. */
1265 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1266 if (STREQN (tokstart, tokentab3[i].operator, 3))
1269 yylval.opcode = tokentab3[i].opcode;
1270 return tokentab3[i].token;
1273 /* See if it is a special token of length 2. */
1274 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1275 if (STREQN (tokstart, tokentab2[i].operator, 2))
1278 yylval.opcode = tokentab2[i].opcode;
1279 return tokentab2[i].token;
1282 switch (c = *tokstart)
1285 /* If we were just scanning the result of a macro expansion,
1286 then we need to resume scanning the original text.
1287 Otherwise, we were already scanning the original text, and
1288 we're really done. */
1289 if (scanning_macro_expansion ())
1291 finished_macro_expansion ();
1304 /* We either have a character constant ('0' or '\177' for example)
1305 or we have a quoted symbol reference ('foo(int,int)' in C++
1310 c = parse_escape (&lexptr);
1312 error ("Empty character constant.");
1314 yylval.typed_val_int.val = c;
1315 yylval.typed_val_int.type = builtin_type_char;
1320 namelen = skip_quoted (tokstart) - tokstart;
1323 lexptr = tokstart + namelen;
1325 if (lexptr[-1] != '\'')
1326 error ("Unmatched single quote.");
1331 error ("Invalid character constant.");
1341 if (paren_depth == 0)
1348 if (comma_terminates
1350 && ! scanning_macro_expansion ())
1356 /* Might be a floating point number. */
1357 if (lexptr[1] < '0' || lexptr[1] > '9')
1358 goto symbol; /* Nope, must be a symbol. */
1359 /* FALL THRU into number case. */
1372 /* It's a number. */
1373 int got_dot = 0, got_e = 0, toktype;
1374 register char *p = tokstart;
1375 int hex = input_radix > 10;
1377 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1382 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1390 /* This test includes !hex because 'e' is a valid hex digit
1391 and thus does not indicate a floating point number when
1392 the radix is hex. */
1393 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1394 got_dot = got_e = 1;
1395 /* This test does not include !hex, because a '.' always indicates
1396 a decimal floating point number regardless of the radix. */
1397 else if (!got_dot && *p == '.')
1399 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1400 && (*p == '-' || *p == '+'))
1401 /* This is the sign of the exponent, not the end of the
1404 /* We will take any letters or digits. parse_number will
1405 complain if past the radix, or if L or U are not final. */
1406 else if ((*p < '0' || *p > '9')
1407 && ((*p < 'a' || *p > 'z')
1408 && (*p < 'A' || *p > 'Z')))
1411 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1412 if (toktype == ERROR)
1414 char *err_copy = (char *) alloca (p - tokstart + 1);
1416 memcpy (err_copy, tokstart, p - tokstart);
1417 err_copy[p - tokstart] = 0;
1418 error ("Invalid number \"%s\".", err_copy);
1450 /* Build the gdb internal form of the input string in tempbuf,
1451 translating any standard C escape forms seen. Note that the
1452 buffer is null byte terminated *only* for the convenience of
1453 debugging gdb itself and printing the buffer contents when
1454 the buffer contains no embedded nulls. Gdb does not depend
1455 upon the buffer being null byte terminated, it uses the length
1456 string instead. This allows gdb to handle C strings (as well
1457 as strings in other languages) with embedded null bytes */
1459 tokptr = ++tokstart;
1463 /* Grow the static temp buffer if necessary, including allocating
1464 the first one on demand. */
1465 if (tempbufindex + 1 >= tempbufsize)
1467 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1473 /* Do nothing, loop will terminate. */
1477 c = parse_escape (&tokptr);
1482 tempbuf[tempbufindex++] = c;
1485 tempbuf[tempbufindex++] = *tokptr++;
1488 } while ((*tokptr != '"') && (*tokptr != '\0'));
1489 if (*tokptr++ != '"')
1491 error ("Unterminated string in expression.");
1493 tempbuf[tempbufindex] = '\0'; /* See note above */
1494 yylval.sval.ptr = tempbuf;
1495 yylval.sval.length = tempbufindex;
1500 if (!(c == '_' || c == '$'
1501 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1502 /* We must have come across a bad character (e.g. ';'). */
1503 error ("Invalid character '%c' in expression.", c);
1505 /* It's a name. See how long it is. */
1507 for (c = tokstart[namelen];
1508 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1509 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1511 /* Template parameter lists are part of the name.
1512 FIXME: This mishandles `print $a<4&&$a>3'. */
1516 /* Scan ahead to get rest of the template specification. Note
1517 that we look ahead only when the '<' adjoins non-whitespace
1518 characters; for comparison expressions, e.g. "a < b > c",
1519 there must be spaces before the '<', etc. */
1521 char * p = find_template_name_end (tokstart + namelen);
1523 namelen = p - tokstart;
1526 c = tokstart[++namelen];
1529 /* The token "if" terminates the expression and is NOT removed from
1530 the input stream. It doesn't count if it appears in the
1531 expansion of a macro. */
1533 && tokstart[0] == 'i'
1534 && tokstart[1] == 'f'
1535 && ! scanning_macro_expansion ())
1544 /* Catch specific keywords. Should be done with a data structure. */
1548 if (STREQN (tokstart, "unsigned", 8))
1550 if (current_language->la_language == language_cplus
1551 && STREQN (tokstart, "template", 8))
1553 if (STREQN (tokstart, "volatile", 8))
1554 return VOLATILE_KEYWORD;
1557 if (STREQN (tokstart, "struct", 6))
1559 if (STREQN (tokstart, "signed", 6))
1560 return SIGNED_KEYWORD;
1561 if (STREQN (tokstart, "sizeof", 6))
1563 if (STREQN (tokstart, "double", 6))
1564 return DOUBLE_KEYWORD;
1567 if (current_language->la_language == language_cplus)
1569 if (STREQN (tokstart, "false", 5))
1570 return FALSEKEYWORD;
1571 if (STREQN (tokstart, "class", 5))
1574 if (STREQN (tokstart, "union", 5))
1576 if (STREQN (tokstart, "short", 5))
1578 if (STREQN (tokstart, "const", 5))
1579 return CONST_KEYWORD;
1582 if (STREQN (tokstart, "enum", 4))
1584 if (STREQN (tokstart, "long", 4))
1586 if (current_language->la_language == language_cplus)
1588 if (STREQN (tokstart, "true", 4))
1591 if (STREQN (tokstart, "this", 4))
1593 static const char this_name[] =
1594 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1596 if (lookup_symbol (this_name, expression_context_block,
1597 VAR_NAMESPACE, (int *) NULL,
1598 (struct symtab **) NULL))
1604 if (STREQN (tokstart, "int", 3))
1611 yylval.sval.ptr = tokstart;
1612 yylval.sval.length = namelen;
1614 if (*tokstart == '$')
1616 write_dollar_variable (yylval.sval);
1620 /* Look ahead and see if we can consume more of the input
1621 string to get a reasonable class/namespace spec or a
1622 fully-qualified name. This is a kludge to get around the
1623 HP aCC compiler's generation of symbol names with embedded
1624 colons for namespace and nested classes. */
1627 /* Only do it if not inside single quotes */
1628 sym_class = parse_nested_classes_for_hpacc (yylval.sval.ptr, yylval.sval.length,
1629 &token_string, &class_prefix, &lexptr);
1632 /* Replace the current token with the bigger one we found */
1633 yylval.sval.ptr = token_string;
1634 yylval.sval.length = strlen (token_string);
1638 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1639 functions or symtabs. If this is not so, then ...
1640 Use token-type TYPENAME for symbols that happen to be defined
1641 currently as names of types; NAME for other symbols.
1642 The caller is not constrained to care about the distinction. */
1644 char *tmp = copy_name (yylval.sval);
1646 int is_a_field_of_this = 0;
1649 sym = lookup_symbol (tmp, expression_context_block,
1651 current_language->la_language == language_cplus
1652 ? &is_a_field_of_this : (int *) NULL,
1653 (struct symtab **) NULL);
1654 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1655 no psymtabs (coff, xcoff, or some future change to blow away the
1656 psymtabs once once symbols are read). */
1657 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1659 yylval.ssym.sym = sym;
1660 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1664 { /* See if it's a file name. */
1665 struct symtab *symtab;
1667 symtab = lookup_symtab (tmp);
1671 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1676 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1679 /* Despite the following flaw, we need to keep this code enabled.
1680 Because we can get called from check_stub_method, if we don't
1681 handle nested types then it screws many operations in any
1682 program which uses nested types. */
1683 /* In "A::x", if x is a member function of A and there happens
1684 to be a type (nested or not, since the stabs don't make that
1685 distinction) named x, then this code incorrectly thinks we
1686 are dealing with nested types rather than a member function. */
1690 struct symbol *best_sym;
1692 /* Look ahead to detect nested types. This probably should be
1693 done in the grammar, but trying seemed to introduce a lot
1694 of shift/reduce and reduce/reduce conflicts. It's possible
1695 that it could be done, though. Or perhaps a non-grammar, but
1696 less ad hoc, approach would work well. */
1698 /* Since we do not currently have any way of distinguishing
1699 a nested type from a non-nested one (the stabs don't tell
1700 us whether a type is nested), we just ignore the
1707 /* Skip whitespace. */
1708 while (*p == ' ' || *p == '\t' || *p == '\n')
1710 if (*p == ':' && p[1] == ':')
1712 /* Skip the `::'. */
1714 /* Skip whitespace. */
1715 while (*p == ' ' || *p == '\t' || *p == '\n')
1718 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1719 || (*p >= 'a' && *p <= 'z')
1720 || (*p >= 'A' && *p <= 'Z'))
1724 struct symbol *cur_sym;
1725 /* As big as the whole rest of the expression, which is
1726 at least big enough. */
1727 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1731 memcpy (tmp1, tmp, strlen (tmp));
1732 tmp1 += strlen (tmp);
1733 memcpy (tmp1, "::", 2);
1735 memcpy (tmp1, namestart, p - namestart);
1736 tmp1[p - namestart] = '\0';
1737 cur_sym = lookup_symbol (ncopy, expression_context_block,
1738 VAR_NAMESPACE, (int *) NULL,
1739 (struct symtab **) NULL);
1742 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1760 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1762 yylval.tsym.type = SYMBOL_TYPE (sym);
1766 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1769 /* Input names that aren't symbols but ARE valid hex numbers,
1770 when the input radix permits them, can be names or numbers
1771 depending on the parse. Note we support radixes > 16 here. */
1773 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1774 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1776 YYSTYPE newlval; /* Its value is ignored. */
1777 hextype = parse_number (tokstart, namelen, 0, &newlval);
1780 yylval.ssym.sym = sym;
1781 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1786 /* Any other kind of symbol */
1787 yylval.ssym.sym = sym;
1788 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1798 lexptr = prev_lexptr;
1800 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);