1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* Parse a C expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
42 #include "expression.h"
44 #include "parser-defs.h"
47 #include "bfd.h" /* Required by objfiles.h. */
48 #include "symfile.h" /* Required by objfiles.h. */
49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
51 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
52 as well as gratuitiously global symbol names, so we can have multiple
53 yacc generated parsers in gdb. Note that these are only the variables
54 produced by yacc. If other parser generators (bison, byacc, etc) produce
55 additional global names that conflict at link time, then those parser
56 generators need to be fixed instead of adding those names to this list. */
58 #define yymaxdepth c_maxdepth
59 #define yyparse c_parse
61 #define yyerror c_error
64 #define yydebug c_debug
73 #define yyerrflag c_errflag
74 #define yynerrs c_nerrs
79 #define yystate c_state
85 #define yyreds c_reds /* With YYDEBUG defined */
86 #define yytoks c_toks /* With YYDEBUG defined */
89 #define yydefred c_yydefred
90 #define yydgoto c_yydgoto
91 #define yysindex c_yysindex
92 #define yyrindex c_yyrindex
93 #define yygindex c_yygindex
94 #define yytable c_yytable
95 #define yycheck c_yycheck
98 #define YYDEBUG 0 /* Default to no yydebug support */
102 yyparse PARAMS ((void));
105 yylex PARAMS ((void));
108 yyerror PARAMS ((char *));
112 /* Although the yacc "value" of an expression is not used,
113 since the result is stored in the structure being created,
114 other node types do have values. */
128 struct symtoken ssym;
131 enum exp_opcode opcode;
132 struct internalvar *ivar;
139 /* YYSTYPE gets defined by %union */
141 parse_number PARAMS ((char *, int, int, YYSTYPE *));
144 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
146 %type <tval> type typebase
147 %type <tvec> nonempty_typelist
148 /* %type <bval> block */
150 /* Fancy type parsing. */
151 %type <voidval> func_mod direct_abs_decl abs_decl
153 %type <lval> array_mod
155 %token <typed_val> INT
158 /* Both NAME and TYPENAME tokens represent symbols in the input,
159 and both convey their data as strings.
160 But a TYPENAME is a string that happens to be defined as a typedef
161 or builtin type name (such as int or char)
162 and a NAME is any other symbol.
163 Contexts where this distinction is not important can use the
164 nonterminal "name", which matches either NAME or TYPENAME. */
167 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
168 %token <tsym> TYPENAME
170 %type <ssym> name_not_typename
171 %type <tsym> typename
173 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
174 but which would parse as a valid number in the current input radix.
175 E.g. "c" when input_radix==16. Depending on the parse, it will be
176 turned into a name or into a number. */
178 %token <ssym> NAME_OR_INT
180 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
184 /* Special type cases, put in to allow the parser to distinguish different
186 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
188 %token <voidval> VARIABLE
190 %token <opcode> ASSIGN_MODIFY
197 %right '=' ASSIGN_MODIFY
205 %left '<' '>' LEQ GEQ
210 %right UNARY INCREMENT DECREMENT
211 %right ARROW '.' '[' '('
212 %token <ssym> BLOCKNAME
224 { write_exp_elt_opcode(OP_TYPE);
225 write_exp_elt_type($1);
226 write_exp_elt_opcode(OP_TYPE);}
229 /* Expressions, including the comma operator. */
232 { write_exp_elt_opcode (BINOP_COMMA); }
235 /* Expressions, not including the comma operator. */
236 exp : '*' exp %prec UNARY
237 { write_exp_elt_opcode (UNOP_IND); }
239 exp : '&' exp %prec UNARY
240 { write_exp_elt_opcode (UNOP_ADDR); }
242 exp : '-' exp %prec UNARY
243 { write_exp_elt_opcode (UNOP_NEG); }
246 exp : '!' exp %prec UNARY
247 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
250 exp : '~' exp %prec UNARY
251 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
254 exp : INCREMENT exp %prec UNARY
255 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
258 exp : DECREMENT exp %prec UNARY
259 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
262 exp : exp INCREMENT %prec UNARY
263 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
266 exp : exp DECREMENT %prec UNARY
267 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
270 exp : SIZEOF exp %prec UNARY
271 { write_exp_elt_opcode (UNOP_SIZEOF); }
275 { write_exp_elt_opcode (STRUCTOP_PTR);
276 write_exp_string ($3);
277 write_exp_elt_opcode (STRUCTOP_PTR); }
280 exp : exp ARROW qualified_name
281 { /* exp->type::name becomes exp->*(&type::name) */
282 /* Note: this doesn't work if name is a
283 static member! FIXME */
284 write_exp_elt_opcode (UNOP_ADDR);
285 write_exp_elt_opcode (STRUCTOP_MPTR); }
287 exp : exp ARROW '*' exp
288 { write_exp_elt_opcode (STRUCTOP_MPTR); }
292 { write_exp_elt_opcode (STRUCTOP_STRUCT);
293 write_exp_string ($3);
294 write_exp_elt_opcode (STRUCTOP_STRUCT); }
297 exp : exp '.' qualified_name
298 { /* exp.type::name becomes exp.*(&type::name) */
299 /* Note: this doesn't work if name is a
300 static member! FIXME */
301 write_exp_elt_opcode (UNOP_ADDR);
302 write_exp_elt_opcode (STRUCTOP_MEMBER); }
305 exp : exp '.' '*' exp
306 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
309 exp : exp '[' exp1 ']'
310 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
314 /* This is to save the value of arglist_len
315 being accumulated by an outer function call. */
316 { start_arglist (); }
317 arglist ')' %prec ARROW
318 { write_exp_elt_opcode (OP_FUNCALL);
319 write_exp_elt_longcst ((LONGEST) end_arglist ());
320 write_exp_elt_opcode (OP_FUNCALL); }
324 { start_arglist (); }
334 arglist : arglist ',' exp %prec ABOVE_COMMA
339 { $$ = end_arglist () - 1; }
341 exp : lcurly arglist rcurly %prec ARROW
342 { write_exp_elt_opcode (OP_ARRAY);
343 write_exp_elt_longcst ((LONGEST) 0);
344 write_exp_elt_longcst ((LONGEST) $3);
345 write_exp_elt_opcode (OP_ARRAY); }
348 exp : lcurly type rcurly exp %prec UNARY
349 { write_exp_elt_opcode (UNOP_MEMVAL);
350 write_exp_elt_type ($2);
351 write_exp_elt_opcode (UNOP_MEMVAL); }
354 exp : '(' type ')' exp %prec UNARY
355 { write_exp_elt_opcode (UNOP_CAST);
356 write_exp_elt_type ($2);
357 write_exp_elt_opcode (UNOP_CAST); }
364 /* Binary operators in order of decreasing precedence. */
367 { write_exp_elt_opcode (BINOP_REPEAT); }
371 { write_exp_elt_opcode (BINOP_MUL); }
375 { write_exp_elt_opcode (BINOP_DIV); }
379 { write_exp_elt_opcode (BINOP_REM); }
383 { write_exp_elt_opcode (BINOP_ADD); }
387 { write_exp_elt_opcode (BINOP_SUB); }
391 { write_exp_elt_opcode (BINOP_LSH); }
395 { write_exp_elt_opcode (BINOP_RSH); }
399 { write_exp_elt_opcode (BINOP_EQUAL); }
402 exp : exp NOTEQUAL exp
403 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
407 { write_exp_elt_opcode (BINOP_LEQ); }
411 { write_exp_elt_opcode (BINOP_GEQ); }
415 { write_exp_elt_opcode (BINOP_LESS); }
419 { write_exp_elt_opcode (BINOP_GTR); }
423 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
427 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
431 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
435 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
439 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
442 exp : exp '?' exp ':' exp %prec '?'
443 { write_exp_elt_opcode (TERNOP_COND); }
447 { write_exp_elt_opcode (BINOP_ASSIGN); }
450 exp : exp ASSIGN_MODIFY exp
451 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
452 write_exp_elt_opcode ($2);
453 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
457 { write_exp_elt_opcode (OP_LONG);
458 write_exp_elt_type ($1.type);
459 write_exp_elt_longcst ((LONGEST)($1.val));
460 write_exp_elt_opcode (OP_LONG); }
465 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
466 write_exp_elt_opcode (OP_LONG);
467 write_exp_elt_type (val.typed_val.type);
468 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
469 write_exp_elt_opcode (OP_LONG);
475 { write_exp_elt_opcode (OP_DOUBLE);
476 write_exp_elt_type (builtin_type_double);
477 write_exp_elt_dblcst ($1);
478 write_exp_elt_opcode (OP_DOUBLE); }
485 /* Already written by write_dollar_variable. */
488 exp : SIZEOF '(' type ')' %prec UNARY
489 { write_exp_elt_opcode (OP_LONG);
490 write_exp_elt_type (builtin_type_int);
491 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
492 write_exp_elt_opcode (OP_LONG); }
496 { /* C strings are converted into array constants with
497 an explicit null byte added at the end. Thus
498 the array upper bound is the string length.
499 There is no such thing in C as a completely empty
501 char *sp = $1.ptr; int count = $1.length;
504 write_exp_elt_opcode (OP_LONG);
505 write_exp_elt_type (builtin_type_char);
506 write_exp_elt_longcst ((LONGEST)(*sp++));
507 write_exp_elt_opcode (OP_LONG);
509 write_exp_elt_opcode (OP_LONG);
510 write_exp_elt_type (builtin_type_char);
511 write_exp_elt_longcst ((LONGEST)'\0');
512 write_exp_elt_opcode (OP_LONG);
513 write_exp_elt_opcode (OP_ARRAY);
514 write_exp_elt_longcst ((LONGEST) 0);
515 write_exp_elt_longcst ((LONGEST) ($1.length));
516 write_exp_elt_opcode (OP_ARRAY); }
521 { write_exp_elt_opcode (OP_THIS);
522 write_exp_elt_opcode (OP_THIS); }
530 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
534 lookup_symtab (copy_name ($1.stoken));
536 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
538 error ("No file or function \"%s\".",
539 copy_name ($1.stoken));
544 block : block COLONCOLON name
546 = lookup_symbol (copy_name ($3), $1,
547 VAR_NAMESPACE, (int *) NULL,
548 (struct symtab **) NULL);
549 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
550 error ("No function \"%s\" in specified context.",
552 $$ = SYMBOL_BLOCK_VALUE (tem); }
555 variable: block COLONCOLON name
556 { struct symbol *sym;
557 sym = lookup_symbol (copy_name ($3), $1,
558 VAR_NAMESPACE, (int *) NULL,
559 (struct symtab **) NULL);
561 error ("No symbol \"%s\" in specified context.",
564 write_exp_elt_opcode (OP_VAR_VALUE);
565 /* block_found is set by lookup_symbol. */
566 write_exp_elt_block (block_found);
567 write_exp_elt_sym (sym);
568 write_exp_elt_opcode (OP_VAR_VALUE); }
571 qualified_name: typebase COLONCOLON name
573 struct type *type = $1;
574 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
575 && TYPE_CODE (type) != TYPE_CODE_UNION)
576 error ("`%s' is not defined as an aggregate type.",
579 write_exp_elt_opcode (OP_SCOPE);
580 write_exp_elt_type (type);
581 write_exp_string ($3);
582 write_exp_elt_opcode (OP_SCOPE);
584 | typebase COLONCOLON '~' name
586 struct type *type = $1;
587 struct stoken tmp_token;
588 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
589 && TYPE_CODE (type) != TYPE_CODE_UNION)
590 error ("`%s' is not defined as an aggregate type.",
593 if (!STREQ (type_name_no_tag (type), $4.ptr))
594 error ("invalid destructor `%s::~%s'",
595 type_name_no_tag (type), $4.ptr);
597 tmp_token.ptr = (char*) alloca ($4.length + 2);
598 tmp_token.length = $4.length + 1;
599 tmp_token.ptr[0] = '~';
600 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
601 tmp_token.ptr[tmp_token.length] = 0;
602 write_exp_elt_opcode (OP_SCOPE);
603 write_exp_elt_type (type);
604 write_exp_string (tmp_token);
605 write_exp_elt_opcode (OP_SCOPE);
609 variable: qualified_name
612 char *name = copy_name ($2);
614 struct minimal_symbol *msymbol;
617 lookup_symbol (name, (const struct block *) NULL,
618 VAR_NAMESPACE, (int *) NULL,
619 (struct symtab **) NULL);
622 write_exp_elt_opcode (OP_VAR_VALUE);
623 write_exp_elt_block (NULL);
624 write_exp_elt_sym (sym);
625 write_exp_elt_opcode (OP_VAR_VALUE);
629 msymbol = lookup_minimal_symbol (name, NULL, NULL);
632 write_exp_msymbol (msymbol,
633 lookup_function_type (builtin_type_int),
637 if (!have_full_symbols () && !have_partial_symbols ())
638 error ("No symbol table is loaded. Use the \"file\" command.");
640 error ("No symbol \"%s\" in current context.", name);
644 variable: name_not_typename
645 { struct symbol *sym = $1.sym;
649 if (symbol_read_needs_frame (sym))
651 if (innermost_block == 0 ||
652 contained_in (block_found,
654 innermost_block = block_found;
657 write_exp_elt_opcode (OP_VAR_VALUE);
658 /* We want to use the selected frame, not
659 another more inner frame which happens to
660 be in the same block. */
661 write_exp_elt_block (NULL);
662 write_exp_elt_sym (sym);
663 write_exp_elt_opcode (OP_VAR_VALUE);
665 else if ($1.is_a_field_of_this)
667 /* C++: it hangs off of `this'. Must
668 not inadvertently convert from a method call
670 if (innermost_block == 0 ||
671 contained_in (block_found, innermost_block))
672 innermost_block = block_found;
673 write_exp_elt_opcode (OP_THIS);
674 write_exp_elt_opcode (OP_THIS);
675 write_exp_elt_opcode (STRUCTOP_PTR);
676 write_exp_string ($1.stoken);
677 write_exp_elt_opcode (STRUCTOP_PTR);
681 struct minimal_symbol *msymbol;
682 register char *arg = copy_name ($1.stoken);
685 lookup_minimal_symbol (arg, NULL, NULL);
688 write_exp_msymbol (msymbol,
689 lookup_function_type (builtin_type_int),
692 else if (!have_full_symbols () && !have_partial_symbols ())
693 error ("No symbol table is loaded. Use the \"file\" command.");
695 error ("No symbol \"%s\" in current context.",
696 copy_name ($1.stoken));
703 /* "const" and "volatile" are curently ignored. A type qualifier
704 before the type is currently handled in the typebase rule.
705 The reason for recognizing these here (shift/reduce conflicts)
706 might be obsolete now that some pointer to member rules have
708 | typebase CONST_KEYWORD
709 | typebase VOLATILE_KEYWORD
711 { $$ = follow_types ($1); }
712 | typebase CONST_KEYWORD abs_decl
713 { $$ = follow_types ($1); }
714 | typebase VOLATILE_KEYWORD abs_decl
715 { $$ = follow_types ($1); }
719 { push_type (tp_pointer); $$ = 0; }
721 { push_type (tp_pointer); $$ = $2; }
723 { push_type (tp_reference); $$ = 0; }
725 { push_type (tp_reference); $$ = $2; }
729 direct_abs_decl: '(' abs_decl ')'
731 | direct_abs_decl array_mod
734 push_type (tp_array);
739 push_type (tp_array);
743 | direct_abs_decl func_mod
744 { push_type (tp_function); }
746 { push_type (tp_function); }
757 | '(' nonempty_typelist ')'
758 { free ((PTR)$2); $$ = 0; }
761 /* We used to try to recognize more pointer to member types here, but
762 that didn't work (shift/reduce conflicts meant that these rules never
763 got executed). The problem is that
764 int (foo::bar::baz::bizzle)
765 is a function type but
766 int (foo::bar::baz::bizzle::*)
767 is a pointer to member type. Stroustrup loses again! */
770 | typebase COLONCOLON '*'
771 { $$ = lookup_member_type (builtin_type_int, $1); }
774 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
778 { $$ = builtin_type_int; }
780 { $$ = builtin_type_long; }
782 { $$ = builtin_type_short; }
784 { $$ = builtin_type_long; }
785 | UNSIGNED LONG INT_KEYWORD
786 { $$ = builtin_type_unsigned_long; }
788 { $$ = builtin_type_long_long; }
789 | LONG LONG INT_KEYWORD
790 { $$ = builtin_type_long_long; }
792 { $$ = builtin_type_unsigned_long_long; }
793 | UNSIGNED LONG LONG INT_KEYWORD
794 { $$ = builtin_type_unsigned_long_long; }
796 { $$ = builtin_type_short; }
797 | UNSIGNED SHORT INT_KEYWORD
798 { $$ = builtin_type_unsigned_short; }
800 { $$ = lookup_struct (copy_name ($2),
801 expression_context_block); }
803 { $$ = lookup_struct (copy_name ($2),
804 expression_context_block); }
806 { $$ = lookup_union (copy_name ($2),
807 expression_context_block); }
809 { $$ = lookup_enum (copy_name ($2),
810 expression_context_block); }
812 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
814 { $$ = builtin_type_unsigned_int; }
815 | SIGNED_KEYWORD typename
816 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
818 { $$ = builtin_type_int; }
819 | TEMPLATE name '<' type '>'
820 { $$ = lookup_template_type(copy_name($2), $4,
821 expression_context_block);
823 /* "const" and "volatile" are curently ignored. A type qualifier
824 after the type is handled in the ptype rule. I think these could
826 | CONST_KEYWORD typebase { $$ = $2; }
827 | VOLATILE_KEYWORD typebase { $$ = $2; }
833 $$.stoken.ptr = "int";
834 $$.stoken.length = 3;
835 $$.type = builtin_type_int;
839 $$.stoken.ptr = "long";
840 $$.stoken.length = 4;
841 $$.type = builtin_type_long;
845 $$.stoken.ptr = "short";
846 $$.stoken.length = 5;
847 $$.type = builtin_type_short;
853 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
854 $<ivec>$[0] = 1; /* Number of types in vector */
857 | nonempty_typelist ',' type
858 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
859 $$ = (struct type **) realloc ((char *) $1, len);
860 $$[$<ivec>$[0]] = $3;
864 name : NAME { $$ = $1.stoken; }
865 | BLOCKNAME { $$ = $1.stoken; }
866 | TYPENAME { $$ = $1.stoken; }
867 | NAME_OR_INT { $$ = $1.stoken; }
870 name_not_typename : NAME
872 /* These would be useful if name_not_typename was useful, but it is just
873 a fake for "variable", so these cause reduce/reduce conflicts because
874 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
875 =exp) or just an exp. If name_not_typename was ever used in an lvalue
876 context where only a name could occur, this might be useful.
883 /* Take care of parsing a number (anything that starts with a digit).
884 Set yylval and return the token type; update lexptr.
885 LEN is the number of characters in it. */
887 /*** Needs some error checking for the float case ***/
890 parse_number (p, len, parsed_float, putithere)
896 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
897 here, and we do kind of silly things like cast to unsigned. */
898 register LONGEST n = 0;
899 register LONGEST prevn = 0;
904 register int base = input_radix;
907 /* Number of "L" suffixes encountered. */
910 /* We have found a "L" or "U" suffix. */
911 int found_suffix = 0;
913 unsigned LONGEST high_bit;
914 struct type *signed_type;
915 struct type *unsigned_type;
919 /* It's a float since it contains a point or an exponent. */
920 putithere->dval = atof (p);
924 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
958 if (c >= 'A' && c <= 'Z')
960 if (c != 'l' && c != 'u')
962 if (c >= '0' && c <= '9')
970 if (base > 10 && c >= 'a' && c <= 'f')
974 n += i = c - 'a' + 10;
987 return ERROR; /* Char not a digit */
990 return ERROR; /* Invalid digit in this base */
992 /* Portably test for overflow (only works for nonzero values, so make
993 a second check for zero). FIXME: Can't we just make n and prevn
994 unsigned and avoid this? */
995 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
996 unsigned_p = 1; /* Try something unsigned */
998 /* Portably test for unsigned overflow.
999 FIXME: This check is wrong; for example it doesn't find overflow
1000 on 0x123456789 when LONGEST is 32 bits. */
1001 if (c != 'l' && c != 'u' && n != 0)
1003 if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1004 error ("Numeric constant too large.");
1009 /* An integer constant is an int, a long, or a long long. An L
1010 suffix forces it to be long; an LL suffix forces it to be long
1011 long. If not forced to a larger size, it gets the first type of
1012 the above that it fits in. To figure out whether it fits, we
1013 shift it right and see whether anything remains. Note that we
1014 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1015 operation, because many compilers will warn about such a shift
1016 (which always produces a zero result). Sometimes TARGET_INT_BIT
1017 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
1018 the case where it is we just always shift the value more than
1019 once, with fewer bits each time. */
1021 un = (unsigned LONGEST)n >> 2;
1023 && (un >> (TARGET_INT_BIT - 2)) == 0)
1025 high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1027 /* A large decimal (not hex or octal) constant (between INT_MAX
1028 and UINT_MAX) is a long or unsigned long, according to ANSI,
1029 never an unsigned int, but this code treats it as unsigned
1030 int. This probably should be fixed. GCC gives a warning on
1033 unsigned_type = builtin_type_unsigned_int;
1034 signed_type = builtin_type_int;
1036 else if (long_p <= 1
1037 && (un >> (TARGET_LONG_BIT - 2)) == 0)
1039 high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1040 unsigned_type = builtin_type_unsigned_long;
1041 signed_type = builtin_type_long;
1045 high_bit = (((unsigned LONGEST)1)
1046 << (TARGET_LONG_LONG_BIT - 32 - 1)
1050 /* A long long does not fit in a LONGEST. */
1052 (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
1053 unsigned_type = builtin_type_unsigned_long_long;
1054 signed_type = builtin_type_long_long;
1057 putithere->typed_val.val = n;
1059 /* If the high bit of the worked out type is set then this number
1060 has to be unsigned. */
1062 if (unsigned_p || (n & high_bit))
1064 putithere->typed_val.type = unsigned_type;
1068 putithere->typed_val.type = signed_type;
1078 enum exp_opcode opcode;
1081 static const struct token tokentab3[] =
1083 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1084 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1087 static const struct token tokentab2[] =
1089 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1090 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1091 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1092 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1093 {"%=", ASSIGN_MODIFY, BINOP_REM},
1094 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1095 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1096 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1097 {"++", INCREMENT, BINOP_END},
1098 {"--", DECREMENT, BINOP_END},
1099 {"->", ARROW, BINOP_END},
1100 {"&&", ANDAND, BINOP_END},
1101 {"||", OROR, BINOP_END},
1102 {"::", COLONCOLON, BINOP_END},
1103 {"<<", LSH, BINOP_END},
1104 {">>", RSH, BINOP_END},
1105 {"==", EQUAL, BINOP_END},
1106 {"!=", NOTEQUAL, BINOP_END},
1107 {"<=", LEQ, BINOP_END},
1108 {">=", GEQ, BINOP_END}
1111 /* Read one token, getting characters through lexptr. */
1122 static char *tempbuf;
1123 static int tempbufsize;
1128 /* See if it is a special token of length 3. */
1129 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1130 if (STREQN (tokstart, tokentab3[i].operator, 3))
1133 yylval.opcode = tokentab3[i].opcode;
1134 return tokentab3[i].token;
1137 /* See if it is a special token of length 2. */
1138 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1139 if (STREQN (tokstart, tokentab2[i].operator, 2))
1142 yylval.opcode = tokentab2[i].opcode;
1143 return tokentab2[i].token;
1146 switch (c = *tokstart)
1158 /* We either have a character constant ('0' or '\177' for example)
1159 or we have a quoted symbol reference ('foo(int,int)' in C++
1164 c = parse_escape (&lexptr);
1166 error ("Empty character constant.");
1168 yylval.typed_val.val = c;
1169 yylval.typed_val.type = builtin_type_char;
1174 namelen = skip_quoted (tokstart) - tokstart;
1177 lexptr = tokstart + namelen;
1178 if (lexptr[-1] != '\'')
1179 error ("Unmatched single quote.");
1184 error ("Invalid character constant.");
1194 if (paren_depth == 0)
1201 if (comma_terminates && paren_depth == 0)
1207 /* Might be a floating point number. */
1208 if (lexptr[1] < '0' || lexptr[1] > '9')
1209 goto symbol; /* Nope, must be a symbol. */
1210 /* FALL THRU into number case. */
1223 /* It's a number. */
1224 int got_dot = 0, got_e = 0, toktype;
1225 register char *p = tokstart;
1226 int hex = input_radix > 10;
1228 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1233 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1241 /* This test includes !hex because 'e' is a valid hex digit
1242 and thus does not indicate a floating point number when
1243 the radix is hex. */
1244 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1245 got_dot = got_e = 1;
1246 /* This test does not include !hex, because a '.' always indicates
1247 a decimal floating point number regardless of the radix. */
1248 else if (!got_dot && *p == '.')
1250 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1251 && (*p == '-' || *p == '+'))
1252 /* This is the sign of the exponent, not the end of the
1255 /* We will take any letters or digits. parse_number will
1256 complain if past the radix, or if L or U are not final. */
1257 else if ((*p < '0' || *p > '9')
1258 && ((*p < 'a' || *p > 'z')
1259 && (*p < 'A' || *p > 'Z')))
1262 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1263 if (toktype == ERROR)
1265 char *err_copy = (char *) alloca (p - tokstart + 1);
1267 memcpy (err_copy, tokstart, p - tokstart);
1268 err_copy[p - tokstart] = 0;
1269 error ("Invalid number \"%s\".", err_copy);
1301 /* Build the gdb internal form of the input string in tempbuf,
1302 translating any standard C escape forms seen. Note that the
1303 buffer is null byte terminated *only* for the convenience of
1304 debugging gdb itself and printing the buffer contents when
1305 the buffer contains no embedded nulls. Gdb does not depend
1306 upon the buffer being null byte terminated, it uses the length
1307 string instead. This allows gdb to handle C strings (as well
1308 as strings in other languages) with embedded null bytes */
1310 tokptr = ++tokstart;
1314 /* Grow the static temp buffer if necessary, including allocating
1315 the first one on demand. */
1316 if (tempbufindex + 1 >= tempbufsize)
1318 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1324 /* Do nothing, loop will terminate. */
1328 c = parse_escape (&tokptr);
1333 tempbuf[tempbufindex++] = c;
1336 tempbuf[tempbufindex++] = *tokptr++;
1339 } while ((*tokptr != '"') && (*tokptr != '\0'));
1340 if (*tokptr++ != '"')
1342 error ("Unterminated string in expression.");
1344 tempbuf[tempbufindex] = '\0'; /* See note above */
1345 yylval.sval.ptr = tempbuf;
1346 yylval.sval.length = tempbufindex;
1351 if (!(c == '_' || c == '$'
1352 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1353 /* We must have come across a bad character (e.g. ';'). */
1354 error ("Invalid character '%c' in expression.", c);
1356 /* It's a name. See how long it is. */
1358 for (c = tokstart[namelen];
1359 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1360 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1365 while (tokstart[++i] && tokstart[i] != '>');
1366 if (tokstart[i] == '>')
1369 c = tokstart[++namelen];
1372 /* The token "if" terminates the expression and is NOT
1373 removed from the input stream. */
1374 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1383 /* Catch specific keywords. Should be done with a data structure. */
1387 if (STREQN (tokstart, "unsigned", 8))
1389 if (current_language->la_language == language_cplus
1390 && STREQN (tokstart, "template", 8))
1392 if (STREQN (tokstart, "volatile", 8))
1393 return VOLATILE_KEYWORD;
1396 if (STREQN (tokstart, "struct", 6))
1398 if (STREQN (tokstart, "signed", 6))
1399 return SIGNED_KEYWORD;
1400 if (STREQN (tokstart, "sizeof", 6))
1404 if (current_language->la_language == language_cplus
1405 && STREQN (tokstart, "class", 5))
1407 if (STREQN (tokstart, "union", 5))
1409 if (STREQN (tokstart, "short", 5))
1411 if (STREQN (tokstart, "const", 5))
1412 return CONST_KEYWORD;
1415 if (STREQN (tokstart, "enum", 4))
1417 if (STREQN (tokstart, "long", 4))
1419 if (current_language->la_language == language_cplus
1420 && STREQN (tokstart, "this", 4))
1422 static const char this_name[] =
1423 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1425 if (lookup_symbol (this_name, expression_context_block,
1426 VAR_NAMESPACE, (int *) NULL,
1427 (struct symtab **) NULL))
1432 if (STREQN (tokstart, "int", 3))
1439 yylval.sval.ptr = tokstart;
1440 yylval.sval.length = namelen;
1442 if (*tokstart == '$')
1444 write_dollar_variable (yylval.sval);
1448 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1449 functions or symtabs. If this is not so, then ...
1450 Use token-type TYPENAME for symbols that happen to be defined
1451 currently as names of types; NAME for other symbols.
1452 The caller is not constrained to care about the distinction. */
1454 char *tmp = copy_name (yylval.sval);
1456 int is_a_field_of_this = 0;
1459 sym = lookup_symbol (tmp, expression_context_block,
1461 current_language->la_language == language_cplus
1462 ? &is_a_field_of_this : (int *) NULL,
1463 (struct symtab **) NULL);
1464 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1465 no psymtabs (coff, xcoff, or some future change to blow away the
1466 psymtabs once once symbols are read). */
1467 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1468 lookup_symtab (tmp))
1470 yylval.ssym.sym = sym;
1471 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1474 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1477 /* Despite the following flaw, we need to keep this code enabled.
1478 Because we can get called from check_stub_method, if we don't
1479 handle nested types then it screws many operations in any
1480 program which uses nested types. */
1481 /* In "A::x", if x is a member function of A and there happens
1482 to be a type (nested or not, since the stabs don't make that
1483 distinction) named x, then this code incorrectly thinks we
1484 are dealing with nested types rather than a member function. */
1488 struct symbol *best_sym;
1490 /* Look ahead to detect nested types. This probably should be
1491 done in the grammar, but trying seemed to introduce a lot
1492 of shift/reduce and reduce/reduce conflicts. It's possible
1493 that it could be done, though. Or perhaps a non-grammar, but
1494 less ad hoc, approach would work well. */
1496 /* Since we do not currently have any way of distinguishing
1497 a nested type from a non-nested one (the stabs don't tell
1498 us whether a type is nested), we just ignore the
1505 /* Skip whitespace. */
1506 while (*p == ' ' || *p == '\t' || *p == '\n')
1508 if (*p == ':' && p[1] == ':')
1510 /* Skip the `::'. */
1512 /* Skip whitespace. */
1513 while (*p == ' ' || *p == '\t' || *p == '\n')
1516 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1517 || (*p >= 'a' && *p <= 'z')
1518 || (*p >= 'A' && *p <= 'Z'))
1522 struct symbol *cur_sym;
1523 /* As big as the whole rest of the expression, which is
1524 at least big enough. */
1525 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1529 memcpy (tmp1, tmp, strlen (tmp));
1530 tmp1 += strlen (tmp);
1531 memcpy (tmp1, "::", 2);
1533 memcpy (tmp1, namestart, p - namestart);
1534 tmp1[p - namestart] = '\0';
1535 cur_sym = lookup_symbol (ncopy, expression_context_block,
1536 VAR_NAMESPACE, (int *) NULL,
1537 (struct symtab **) NULL);
1540 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1558 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1560 yylval.tsym.type = SYMBOL_TYPE (sym);
1564 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1567 /* Input names that aren't symbols but ARE valid hex numbers,
1568 when the input radix permits them, can be names or numbers
1569 depending on the parse. Note we support radixes > 16 here. */
1571 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1572 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1574 YYSTYPE newlval; /* Its value is ignored. */
1575 hextype = parse_number (tokstart, namelen, 0, &newlval);
1578 yylval.ssym.sym = sym;
1579 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1584 /* Any other kind of symbol */
1585 yylval.ssym.sym = sym;
1586 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1595 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);