1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Parse a C expression from text in a string,
21 and return the result as a struct expression pointer.
22 That structure contains arithmetic operations in reverse polish,
23 with constants represented by operations that are followed by special data.
24 See expression.h for the details of the format.
25 What is important here is that it can be built up sequentially
26 during the process of parsing; the lower levels of the tree always
27 come first in the result.
29 Note that malloc's and realloc's in this file are transformed to
30 xmalloc and xrealloc respectively by the same sed command in the
31 makefile that remaps any other malloc/realloc inserted by the parser
32 generator. Doing this with #defines and trying to control the interaction
33 with include files (<malloc.h> and <stdlib.h> for example) just became
34 too messy, particularly when such includes can be inserted at random
35 times by the parser generator. */
40 #include "expression.h"
42 #include "parser-defs.h"
45 #include "bfd.h" /* Required by objfiles.h. */
46 #include "symfile.h" /* Required by objfiles.h. */
47 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
49 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
50 as well as gratuitiously global symbol names, so we can have multiple
51 yacc generated parsers in gdb. Note that these are only the variables
52 produced by yacc. If other parser generators (bison, byacc, etc) produce
53 additional global names that conflict at link time, then those parser
54 generators need to be fixed instead of adding those names to this list. */
56 #define yymaxdepth c_maxdepth
57 #define yyparse c_parse
59 #define yyerror c_error
62 #define yydebug c_debug
71 #define yyerrflag c_errflag
72 #define yynerrs c_nerrs
77 #define yystate c_state
83 #define yyreds c_reds /* With YYDEBUG defined */
84 #define yytoks c_toks /* With YYDEBUG defined */
87 #define YYDEBUG 0 /* Default to no yydebug support */
91 yyparse PARAMS ((void));
94 yylex PARAMS ((void));
97 yyerror PARAMS ((char *));
101 /* Although the yacc "value" of an expression is not used,
102 since the result is stored in the structure being created,
103 other node types do have values. */
117 struct symtoken ssym;
120 enum exp_opcode opcode;
121 struct internalvar *ivar;
128 /* YYSTYPE gets defined by %union */
130 parse_number PARAMS ((char *, int, int, YYSTYPE *));
133 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
135 %type <tval> type typebase
136 %type <tvec> nonempty_typelist
137 /* %type <bval> block */
139 /* Fancy type parsing. */
140 %type <voidval> func_mod direct_abs_decl abs_decl
142 %type <lval> array_mod
144 %token <typed_val> INT
147 /* Both NAME and TYPENAME tokens represent symbols in the input,
148 and both convey their data as strings.
149 But a TYPENAME is a string that happens to be defined as a typedef
150 or builtin type name (such as int or char)
151 and a NAME is any other symbol.
152 Contexts where this distinction is not important can use the
153 nonterminal "name", which matches either NAME or TYPENAME. */
156 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
157 %token <tsym> TYPENAME
159 %type <ssym> name_not_typename
160 %type <tsym> typename
162 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
163 but which would parse as a valid number in the current input radix.
164 E.g. "c" when input_radix==16. Depending on the parse, it will be
165 turned into a name or into a number. */
167 %token <ssym> NAME_OR_INT
169 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
173 /* Special type cases, put in to allow the parser to distinguish different
175 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
176 %token <lval> LAST REGNAME
178 %token <ivar> VARIABLE
180 %token <opcode> ASSIGN_MODIFY
187 %right '=' ASSIGN_MODIFY
195 %left '<' '>' LEQ GEQ
200 %right UNARY INCREMENT DECREMENT
201 %right ARROW '.' '[' '('
202 %token <ssym> BLOCKNAME
214 { write_exp_elt_opcode(OP_TYPE);
215 write_exp_elt_type($1);
216 write_exp_elt_opcode(OP_TYPE);}
219 /* Expressions, including the comma operator. */
222 { write_exp_elt_opcode (BINOP_COMMA); }
225 /* Expressions, not including the comma operator. */
226 exp : '*' exp %prec UNARY
227 { write_exp_elt_opcode (UNOP_IND); }
229 exp : '&' exp %prec UNARY
230 { write_exp_elt_opcode (UNOP_ADDR); }
232 exp : '-' exp %prec UNARY
233 { write_exp_elt_opcode (UNOP_NEG); }
236 exp : '!' exp %prec UNARY
237 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
240 exp : '~' exp %prec UNARY
241 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
244 exp : INCREMENT exp %prec UNARY
245 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
248 exp : DECREMENT exp %prec UNARY
249 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
252 exp : exp INCREMENT %prec UNARY
253 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
256 exp : exp DECREMENT %prec UNARY
257 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
260 exp : SIZEOF exp %prec UNARY
261 { write_exp_elt_opcode (UNOP_SIZEOF); }
265 { write_exp_elt_opcode (STRUCTOP_PTR);
266 write_exp_string ($3);
267 write_exp_elt_opcode (STRUCTOP_PTR); }
270 exp : exp ARROW qualified_name
271 { /* exp->type::name becomes exp->*(&type::name) */
272 /* Note: this doesn't work if name is a
273 static member! FIXME */
274 write_exp_elt_opcode (UNOP_ADDR);
275 write_exp_elt_opcode (STRUCTOP_MPTR); }
277 exp : exp ARROW '*' exp
278 { write_exp_elt_opcode (STRUCTOP_MPTR); }
282 { write_exp_elt_opcode (STRUCTOP_STRUCT);
283 write_exp_string ($3);
284 write_exp_elt_opcode (STRUCTOP_STRUCT); }
287 exp : exp '.' qualified_name
288 { /* exp.type::name becomes exp.*(&type::name) */
289 /* Note: this doesn't work if name is a
290 static member! FIXME */
291 write_exp_elt_opcode (UNOP_ADDR);
292 write_exp_elt_opcode (STRUCTOP_MEMBER); }
295 exp : exp '.' '*' exp
296 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
299 exp : exp '[' exp1 ']'
300 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
304 /* This is to save the value of arglist_len
305 being accumulated by an outer function call. */
306 { start_arglist (); }
307 arglist ')' %prec ARROW
308 { write_exp_elt_opcode (OP_FUNCALL);
309 write_exp_elt_longcst ((LONGEST) end_arglist ());
310 write_exp_elt_opcode (OP_FUNCALL); }
314 { start_arglist (); }
324 arglist : arglist ',' exp %prec ABOVE_COMMA
329 { $$ = end_arglist () - 1; }
331 exp : lcurly arglist rcurly %prec ARROW
332 { write_exp_elt_opcode (OP_ARRAY);
333 write_exp_elt_longcst ((LONGEST) 0);
334 write_exp_elt_longcst ((LONGEST) $3);
335 write_exp_elt_opcode (OP_ARRAY); }
338 exp : lcurly type rcurly exp %prec UNARY
339 { write_exp_elt_opcode (UNOP_MEMVAL);
340 write_exp_elt_type ($2);
341 write_exp_elt_opcode (UNOP_MEMVAL); }
344 exp : '(' type ')' exp %prec UNARY
345 { write_exp_elt_opcode (UNOP_CAST);
346 write_exp_elt_type ($2);
347 write_exp_elt_opcode (UNOP_CAST); }
354 /* Binary operators in order of decreasing precedence. */
357 { write_exp_elt_opcode (BINOP_REPEAT); }
361 { write_exp_elt_opcode (BINOP_MUL); }
365 { write_exp_elt_opcode (BINOP_DIV); }
369 { write_exp_elt_opcode (BINOP_REM); }
373 { write_exp_elt_opcode (BINOP_ADD); }
377 { write_exp_elt_opcode (BINOP_SUB); }
381 { write_exp_elt_opcode (BINOP_LSH); }
385 { write_exp_elt_opcode (BINOP_RSH); }
389 { write_exp_elt_opcode (BINOP_EQUAL); }
392 exp : exp NOTEQUAL exp
393 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
397 { write_exp_elt_opcode (BINOP_LEQ); }
401 { write_exp_elt_opcode (BINOP_GEQ); }
405 { write_exp_elt_opcode (BINOP_LESS); }
409 { write_exp_elt_opcode (BINOP_GTR); }
413 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
417 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
421 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
425 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
429 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
432 exp : exp '?' exp ':' exp %prec '?'
433 { write_exp_elt_opcode (TERNOP_COND); }
437 { write_exp_elt_opcode (BINOP_ASSIGN); }
440 exp : exp ASSIGN_MODIFY exp
441 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
442 write_exp_elt_opcode ($2);
443 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
447 { write_exp_elt_opcode (OP_LONG);
448 write_exp_elt_type ($1.type);
449 write_exp_elt_longcst ((LONGEST)($1.val));
450 write_exp_elt_opcode (OP_LONG); }
455 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
456 write_exp_elt_opcode (OP_LONG);
457 write_exp_elt_type (val.typed_val.type);
458 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
459 write_exp_elt_opcode (OP_LONG);
465 { write_exp_elt_opcode (OP_DOUBLE);
466 write_exp_elt_type (builtin_type_double);
467 write_exp_elt_dblcst ($1);
468 write_exp_elt_opcode (OP_DOUBLE); }
475 { write_exp_elt_opcode (OP_LAST);
476 write_exp_elt_longcst ((LONGEST) $1);
477 write_exp_elt_opcode (OP_LAST); }
481 { write_exp_elt_opcode (OP_REGISTER);
482 write_exp_elt_longcst ((LONGEST) $1);
483 write_exp_elt_opcode (OP_REGISTER); }
487 { write_exp_elt_opcode (OP_INTERNALVAR);
488 write_exp_elt_intern ($1);
489 write_exp_elt_opcode (OP_INTERNALVAR); }
492 exp : SIZEOF '(' type ')' %prec UNARY
493 { write_exp_elt_opcode (OP_LONG);
494 write_exp_elt_type (builtin_type_int);
495 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
496 write_exp_elt_opcode (OP_LONG); }
500 { /* C strings are converted into array constants with
501 an explicit null byte added at the end. Thus
502 the array upper bound is the string length.
503 There is no such thing in C as a completely empty
505 char *sp = $1.ptr; int count = $1.length;
508 write_exp_elt_opcode (OP_LONG);
509 write_exp_elt_type (builtin_type_char);
510 write_exp_elt_longcst ((LONGEST)(*sp++));
511 write_exp_elt_opcode (OP_LONG);
513 write_exp_elt_opcode (OP_LONG);
514 write_exp_elt_type (builtin_type_char);
515 write_exp_elt_longcst ((LONGEST)'\0');
516 write_exp_elt_opcode (OP_LONG);
517 write_exp_elt_opcode (OP_ARRAY);
518 write_exp_elt_longcst ((LONGEST) 0);
519 write_exp_elt_longcst ((LONGEST) ($1.length));
520 write_exp_elt_opcode (OP_ARRAY); }
525 { write_exp_elt_opcode (OP_THIS);
526 write_exp_elt_opcode (OP_THIS); }
534 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
538 lookup_symtab (copy_name ($1.stoken));
540 $$ = BLOCKVECTOR_BLOCK
541 (BLOCKVECTOR (tem), STATIC_BLOCK);
543 error ("No file or function \"%s\".",
544 copy_name ($1.stoken));
549 block : block COLONCOLON name
551 = lookup_symbol (copy_name ($3), $1,
552 VAR_NAMESPACE, (int *) NULL,
553 (struct symtab **) NULL);
554 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
555 error ("No function \"%s\" in specified context.",
557 $$ = SYMBOL_BLOCK_VALUE (tem); }
560 variable: block COLONCOLON name
561 { struct symbol *sym;
562 sym = lookup_symbol (copy_name ($3), $1,
563 VAR_NAMESPACE, (int *) NULL,
564 (struct symtab **) NULL);
566 error ("No symbol \"%s\" in specified context.",
569 write_exp_elt_opcode (OP_VAR_VALUE);
570 /* block_found is set by lookup_symbol. */
571 write_exp_elt_block (block_found);
572 write_exp_elt_sym (sym);
573 write_exp_elt_opcode (OP_VAR_VALUE); }
576 qualified_name: typebase COLONCOLON name
578 struct type *type = $1;
579 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
580 && TYPE_CODE (type) != TYPE_CODE_UNION)
581 error ("`%s' is not defined as an aggregate type.",
584 write_exp_elt_opcode (OP_SCOPE);
585 write_exp_elt_type (type);
586 write_exp_string ($3);
587 write_exp_elt_opcode (OP_SCOPE);
589 | typebase COLONCOLON '~' name
591 struct type *type = $1;
592 struct stoken tmp_token;
593 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
594 && TYPE_CODE (type) != TYPE_CODE_UNION)
595 error ("`%s' is not defined as an aggregate type.",
598 if (!STREQ (type_name_no_tag (type), $4.ptr))
599 error ("invalid destructor `%s::~%s'",
600 type_name_no_tag (type), $4.ptr);
602 tmp_token.ptr = (char*) alloca ($4.length + 2);
603 tmp_token.length = $4.length + 1;
604 tmp_token.ptr[0] = '~';
605 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
606 tmp_token.ptr[tmp_token.length] = 0;
607 write_exp_elt_opcode (OP_SCOPE);
608 write_exp_elt_type (type);
609 write_exp_string (tmp_token);
610 write_exp_elt_opcode (OP_SCOPE);
614 variable: qualified_name
617 char *name = copy_name ($2);
619 struct minimal_symbol *msymbol;
622 lookup_symbol (name, (const struct block *) NULL,
623 VAR_NAMESPACE, (int *) NULL,
624 (struct symtab **) NULL);
627 write_exp_elt_opcode (OP_VAR_VALUE);
628 write_exp_elt_block (NULL);
629 write_exp_elt_sym (sym);
630 write_exp_elt_opcode (OP_VAR_VALUE);
634 msymbol = lookup_minimal_symbol (name,
635 (struct objfile *) NULL);
638 write_exp_msymbol (msymbol,
639 lookup_function_type (builtin_type_int),
643 if (!have_full_symbols () && !have_partial_symbols ())
644 error ("No symbol table is loaded. Use the \"file\" command.");
646 error ("No symbol \"%s\" in current context.", name);
650 variable: name_not_typename
651 { struct symbol *sym = $1.sym;
655 if (symbol_read_needs_frame (sym))
657 if (innermost_block == 0 ||
658 contained_in (block_found,
660 innermost_block = block_found;
663 write_exp_elt_opcode (OP_VAR_VALUE);
664 /* We want to use the selected frame, not
665 another more inner frame which happens to
666 be in the same block. */
667 write_exp_elt_block (NULL);
668 write_exp_elt_sym (sym);
669 write_exp_elt_opcode (OP_VAR_VALUE);
671 else if ($1.is_a_field_of_this)
673 /* C++: it hangs off of `this'. Must
674 not inadvertently convert from a method call
676 if (innermost_block == 0 ||
677 contained_in (block_found, innermost_block))
678 innermost_block = block_found;
679 write_exp_elt_opcode (OP_THIS);
680 write_exp_elt_opcode (OP_THIS);
681 write_exp_elt_opcode (STRUCTOP_PTR);
682 write_exp_string ($1.stoken);
683 write_exp_elt_opcode (STRUCTOP_PTR);
687 struct minimal_symbol *msymbol;
688 register char *arg = copy_name ($1.stoken);
690 msymbol = lookup_minimal_symbol (arg,
691 (struct objfile *) NULL);
694 write_exp_msymbol (msymbol,
695 lookup_function_type (builtin_type_int),
698 else if (!have_full_symbols () && !have_partial_symbols ())
699 error ("No symbol table is loaded. Use the \"file\" command.");
701 error ("No symbol \"%s\" in current context.",
702 copy_name ($1.stoken));
709 /* "const" and "volatile" are curently ignored. A type qualifier
710 before the type is currently handled in the typebase rule.
711 The reason for recognizing these here (shift/reduce conflicts)
712 might be obsolete now that some pointer to member rules have
714 | typebase CONST_KEYWORD
715 | typebase VOLATILE_KEYWORD
717 { $$ = follow_types ($1); }
718 | typebase CONST_KEYWORD abs_decl
719 { $$ = follow_types ($1); }
720 | typebase VOLATILE_KEYWORD abs_decl
721 { $$ = follow_types ($1); }
725 { push_type (tp_pointer); $$ = 0; }
727 { push_type (tp_pointer); $$ = $2; }
729 { push_type (tp_reference); $$ = 0; }
731 { push_type (tp_reference); $$ = $2; }
735 direct_abs_decl: '(' abs_decl ')'
737 | direct_abs_decl array_mod
740 push_type (tp_array);
745 push_type (tp_array);
749 | direct_abs_decl func_mod
750 { push_type (tp_function); }
752 { push_type (tp_function); }
763 | '(' nonempty_typelist ')'
764 { free ((PTR)$2); $$ = 0; }
767 /* We used to try to recognize more pointer to member types here, but
768 that didn't work (shift/reduce conflicts meant that these rules never
769 got executed). The problem is that
770 int (foo::bar::baz::bizzle)
771 is a function type but
772 int (foo::bar::baz::bizzle::*)
773 is a pointer to member type. Stroustrup loses again! */
776 | typebase COLONCOLON '*'
777 { $$ = lookup_member_type (builtin_type_int, $1); }
780 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
784 { $$ = builtin_type_int; }
786 { $$ = builtin_type_long; }
788 { $$ = builtin_type_short; }
790 { $$ = builtin_type_long; }
791 | UNSIGNED LONG INT_KEYWORD
792 { $$ = builtin_type_unsigned_long; }
794 { $$ = builtin_type_long_long; }
795 | LONG LONG INT_KEYWORD
796 { $$ = builtin_type_long_long; }
798 { $$ = builtin_type_unsigned_long_long; }
799 | UNSIGNED LONG LONG INT_KEYWORD
800 { $$ = builtin_type_unsigned_long_long; }
802 { $$ = builtin_type_short; }
803 | UNSIGNED SHORT INT_KEYWORD
804 { $$ = builtin_type_unsigned_short; }
806 { $$ = lookup_struct (copy_name ($2),
807 expression_context_block); }
809 { $$ = lookup_struct (copy_name ($2),
810 expression_context_block); }
812 { $$ = lookup_union (copy_name ($2),
813 expression_context_block); }
815 { $$ = lookup_enum (copy_name ($2),
816 expression_context_block); }
818 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
820 { $$ = builtin_type_unsigned_int; }
821 | SIGNED_KEYWORD typename
822 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
824 { $$ = builtin_type_int; }
825 | TEMPLATE name '<' type '>'
826 { $$ = lookup_template_type(copy_name($2), $4,
827 expression_context_block);
829 /* "const" and "volatile" are curently ignored. A type qualifier
830 after the type is handled in the ptype rule. I think these could
832 | CONST_KEYWORD typebase { $$ = $2; }
833 | VOLATILE_KEYWORD typebase { $$ = $2; }
839 $$.stoken.ptr = "int";
840 $$.stoken.length = 3;
841 $$.type = builtin_type_int;
845 $$.stoken.ptr = "long";
846 $$.stoken.length = 4;
847 $$.type = builtin_type_long;
851 $$.stoken.ptr = "short";
852 $$.stoken.length = 5;
853 $$.type = builtin_type_short;
859 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
860 $<ivec>$[0] = 1; /* Number of types in vector */
863 | nonempty_typelist ',' type
864 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
865 $$ = (struct type **) realloc ((char *) $1, len);
866 $$[$<ivec>$[0]] = $3;
870 name : NAME { $$ = $1.stoken; }
871 | BLOCKNAME { $$ = $1.stoken; }
872 | TYPENAME { $$ = $1.stoken; }
873 | NAME_OR_INT { $$ = $1.stoken; }
876 name_not_typename : NAME
878 /* These would be useful if name_not_typename was useful, but it is just
879 a fake for "variable", so these cause reduce/reduce conflicts because
880 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
881 =exp) or just an exp. If name_not_typename was ever used in an lvalue
882 context where only a name could occur, this might be useful.
889 /* Take care of parsing a number (anything that starts with a digit).
890 Set yylval and return the token type; update lexptr.
891 LEN is the number of characters in it. */
893 /*** Needs some error checking for the float case ***/
896 parse_number (p, len, parsed_float, putithere)
902 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
903 here, and we do kind of silly things like cast to unsigned. */
904 register LONGEST n = 0;
905 register LONGEST prevn = 0;
909 register int base = input_radix;
912 /* Number of "L" suffixes encountered. */
915 /* We have found a "L" or "U" suffix. */
916 int found_suffix = 0;
918 unsigned LONGEST high_bit;
919 struct type *signed_type;
920 struct type *unsigned_type;
924 /* It's a float since it contains a point or an exponent. */
925 putithere->dval = atof (p);
929 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
963 if (c >= 'A' && c <= 'Z')
965 if (c != 'l' && c != 'u')
967 if (c >= '0' && c <= '9')
975 if (base > 10 && c >= 'a' && c <= 'f')
979 n += i = c - 'a' + 10;
992 return ERROR; /* Char not a digit */
995 return ERROR; /* Invalid digit in this base */
997 /* Portably test for overflow (only works for nonzero values, so make
998 a second check for zero). FIXME: Can't we just make n and prevn
999 unsigned and avoid this? */
1000 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1001 unsigned_p = 1; /* Try something unsigned */
1003 /* Portably test for unsigned overflow.
1004 FIXME: This check is wrong; for example it doesn't find overflow
1005 on 0x123456789 when LONGEST is 32 bits. */
1006 if (c != 'l' && c != 'u' && n != 0)
1008 if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1009 error ("Numeric constant too large.");
1014 /* An integer constant is an int, a long, or a long long. An L
1015 suffix forces it to be long; an LL suffix forces it to be long
1016 long. If not forced to a larger size, it gets the first type of
1017 the above that it fits in. To figure out whether it fits, we
1018 shift it right and see whether anything remains. Note that we
1019 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1020 operation, because many compilers will warn about such a shift
1021 (which always produces a zero result). Sometimes TARGET_INT_BIT
1022 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
1023 the case where it is we just always shift the value more than
1024 once, with fewer bits each time. */
1027 && (((unsigned LONGEST)n >> 2) >> (TARGET_INT_BIT - 2)) == 0)
1029 high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1031 /* A large decimal (not hex or octal) constant (between INT_MAX
1032 and UINT_MAX) is a long or unsigned long, according to ANSI,
1033 never an unsigned int, but this code treats it as unsigned
1034 int. This probably should be fixed. GCC gives a warning on
1037 unsigned_type = builtin_type_unsigned_int;
1038 signed_type = builtin_type_int;
1040 else if (long_p <= 1
1041 && (((unsigned LONGEST)n >> 2) >> (TARGET_LONG_BIT - 2)) == 0)
1043 high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1044 unsigned_type = builtin_type_unsigned_long;
1045 signed_type = builtin_type_long;
1049 high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_LONG_BIT - 1);
1050 unsigned_type = builtin_type_unsigned_long_long;
1051 signed_type = builtin_type_long_long;
1054 putithere->typed_val.val = n;
1056 /* If the high bit of the worked out type is set then this number
1057 has to be unsigned. */
1059 if (unsigned_p || (n & high_bit))
1061 putithere->typed_val.type = unsigned_type;
1065 putithere->typed_val.type = signed_type;
1075 enum exp_opcode opcode;
1078 static const struct token tokentab3[] =
1080 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1081 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1084 static const struct token tokentab2[] =
1086 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1087 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1088 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1089 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1090 {"%=", ASSIGN_MODIFY, BINOP_REM},
1091 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1092 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1093 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1094 {"++", INCREMENT, BINOP_END},
1095 {"--", DECREMENT, BINOP_END},
1096 {"->", ARROW, BINOP_END},
1097 {"&&", ANDAND, BINOP_END},
1098 {"||", OROR, BINOP_END},
1099 {"::", COLONCOLON, BINOP_END},
1100 {"<<", LSH, BINOP_END},
1101 {">>", RSH, BINOP_END},
1102 {"==", EQUAL, BINOP_END},
1103 {"!=", NOTEQUAL, BINOP_END},
1104 {"<=", LEQ, BINOP_END},
1105 {">=", GEQ, BINOP_END}
1108 /* Read one token, getting characters through lexptr. */
1119 static char *tempbuf;
1120 static int tempbufsize;
1125 /* See if it is a special token of length 3. */
1126 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1127 if (STREQN (tokstart, tokentab3[i].operator, 3))
1130 yylval.opcode = tokentab3[i].opcode;
1131 return tokentab3[i].token;
1134 /* See if it is a special token of length 2. */
1135 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1136 if (STREQN (tokstart, tokentab2[i].operator, 2))
1139 yylval.opcode = tokentab2[i].opcode;
1140 return tokentab2[i].token;
1143 switch (c = *tokstart)
1155 /* We either have a character constant ('0' or '\177' for example)
1156 or we have a quoted symbol reference ('foo(int,int)' in C++
1161 c = parse_escape (&lexptr);
1163 yylval.typed_val.val = c;
1164 yylval.typed_val.type = builtin_type_char;
1169 namelen = skip_quoted (tokstart) - tokstart;
1172 lexptr = tokstart + namelen;
1173 if (lexptr[-1] != '\'')
1174 error ("Unmatched single quote.");
1179 error ("Invalid character constant.");
1189 if (paren_depth == 0)
1196 if (comma_terminates && paren_depth == 0)
1202 /* Might be a floating point number. */
1203 if (lexptr[1] < '0' || lexptr[1] > '9')
1204 goto symbol; /* Nope, must be a symbol. */
1205 /* FALL THRU into number case. */
1218 /* It's a number. */
1219 int got_dot = 0, got_e = 0, toktype;
1220 register char *p = tokstart;
1221 int hex = input_radix > 10;
1223 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1228 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1236 /* This test includes !hex because 'e' is a valid hex digit
1237 and thus does not indicate a floating point number when
1238 the radix is hex. */
1239 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1240 got_dot = got_e = 1;
1241 /* This test does not include !hex, because a '.' always indicates
1242 a decimal floating point number regardless of the radix. */
1243 else if (!got_dot && *p == '.')
1245 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1246 && (*p == '-' || *p == '+'))
1247 /* This is the sign of the exponent, not the end of the
1250 /* We will take any letters or digits. parse_number will
1251 complain if past the radix, or if L or U are not final. */
1252 else if ((*p < '0' || *p > '9')
1253 && ((*p < 'a' || *p > 'z')
1254 && (*p < 'A' || *p > 'Z')))
1257 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1258 if (toktype == ERROR)
1260 char *err_copy = (char *) alloca (p - tokstart + 1);
1262 memcpy (err_copy, tokstart, p - tokstart);
1263 err_copy[p - tokstart] = 0;
1264 error ("Invalid number \"%s\".", err_copy);
1296 /* Build the gdb internal form of the input string in tempbuf,
1297 translating any standard C escape forms seen. Note that the
1298 buffer is null byte terminated *only* for the convenience of
1299 debugging gdb itself and printing the buffer contents when
1300 the buffer contains no embedded nulls. Gdb does not depend
1301 upon the buffer being null byte terminated, it uses the length
1302 string instead. This allows gdb to handle C strings (as well
1303 as strings in other languages) with embedded null bytes */
1305 tokptr = ++tokstart;
1309 /* Grow the static temp buffer if necessary, including allocating
1310 the first one on demand. */
1311 if (tempbufindex + 1 >= tempbufsize)
1313 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1319 /* Do nothing, loop will terminate. */
1323 c = parse_escape (&tokptr);
1328 tempbuf[tempbufindex++] = c;
1331 tempbuf[tempbufindex++] = *tokptr++;
1334 } while ((*tokptr != '"') && (*tokptr != '\0'));
1335 if (*tokptr++ != '"')
1337 error ("Unterminated string in expression.");
1339 tempbuf[tempbufindex] = '\0'; /* See note above */
1340 yylval.sval.ptr = tempbuf;
1341 yylval.sval.length = tempbufindex;
1346 if (!(c == '_' || c == '$'
1347 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1348 /* We must have come across a bad character (e.g. ';'). */
1349 error ("Invalid character '%c' in expression.", c);
1351 /* It's a name. See how long it is. */
1353 for (c = tokstart[namelen];
1354 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1355 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1356 c = tokstart[++namelen])
1359 /* The token "if" terminates the expression and is NOT
1360 removed from the input stream. */
1361 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1368 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1369 and $$digits (equivalent to $<-digits> if you could type that).
1370 Make token type LAST, and put the number (the digits) in yylval. */
1373 if (*tokstart == '$')
1375 register int negate = 0;
1377 /* Double dollar means negate the number and add -1 as well.
1378 Thus $$ alone means -1. */
1379 if (namelen >= 2 && tokstart[1] == '$')
1386 /* Just dollars (one or two) */
1387 yylval.lval = - negate;
1390 /* Is the rest of the token digits? */
1391 for (; c < namelen; c++)
1392 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1396 yylval.lval = atoi (tokstart + 1 + negate);
1398 yylval.lval = - yylval.lval;
1403 /* Handle tokens that refer to machine registers:
1404 $ followed by a register name. */
1406 if (*tokstart == '$') {
1407 for (c = 0; c < NUM_REGS; c++)
1408 if (namelen - 1 == strlen (reg_names[c])
1409 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1414 for (c = 0; c < num_std_regs; c++)
1415 if (namelen - 1 == strlen (std_regs[c].name)
1416 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1418 yylval.lval = std_regs[c].regnum;
1422 /* Catch specific keywords. Should be done with a data structure. */
1426 if (STREQN (tokstart, "unsigned", 8))
1428 if (current_language->la_language == language_cplus
1429 && STREQN (tokstart, "template", 8))
1431 if (STREQN (tokstart, "volatile", 8))
1432 return VOLATILE_KEYWORD;
1435 if (STREQN (tokstart, "struct", 6))
1437 if (STREQN (tokstart, "signed", 6))
1438 return SIGNED_KEYWORD;
1439 if (STREQN (tokstart, "sizeof", 6))
1443 if (current_language->la_language == language_cplus
1444 && STREQN (tokstart, "class", 5))
1446 if (STREQN (tokstart, "union", 5))
1448 if (STREQN (tokstart, "short", 5))
1450 if (STREQN (tokstart, "const", 5))
1451 return CONST_KEYWORD;
1454 if (STREQN (tokstart, "enum", 4))
1456 if (STREQN (tokstart, "long", 4))
1458 if (current_language->la_language == language_cplus
1459 && STREQN (tokstart, "this", 4))
1461 static const char this_name[] =
1462 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1464 if (lookup_symbol (this_name, expression_context_block,
1465 VAR_NAMESPACE, (int *) NULL,
1466 (struct symtab **) NULL))
1471 if (STREQN (tokstart, "int", 3))
1478 yylval.sval.ptr = tokstart;
1479 yylval.sval.length = namelen;
1481 /* Any other names starting in $ are debugger internal variables. */
1483 if (*tokstart == '$')
1485 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1489 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1490 functions or symtabs. If this is not so, then ...
1491 Use token-type TYPENAME for symbols that happen to be defined
1492 currently as names of types; NAME for other symbols.
1493 The caller is not constrained to care about the distinction. */
1495 char *tmp = copy_name (yylval.sval);
1497 int is_a_field_of_this = 0;
1500 sym = lookup_symbol (tmp, expression_context_block,
1502 current_language->la_language == language_cplus
1503 ? &is_a_field_of_this : (int *) NULL,
1504 (struct symtab **) NULL);
1505 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1506 no psymtabs (coff, xcoff, or some future change to blow away the
1507 psymtabs once once symbols are read). */
1508 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1509 lookup_symtab (tmp))
1511 yylval.ssym.sym = sym;
1512 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1515 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1518 /* In "A::x", if x is a member function of A and there happens
1519 to be a type (nested or not, since the stabs don't make that
1520 distinction) named x, then this code incorrectly thinks we
1521 are dealing with nested types rather than a member function. */
1525 struct symbol *best_sym;
1527 /* Look ahead to detect nested types. This probably should be
1528 done in the grammar, but trying seemed to introduce a lot
1529 of shift/reduce and reduce/reduce conflicts. It's possible
1530 that it could be done, though. Or perhaps a non-grammar, but
1531 less ad hoc, approach would work well. */
1533 /* Since we do not currently have any way of distinguishing
1534 a nested type from a non-nested one (the stabs don't tell
1535 us whether a type is nested), we just ignore the
1542 /* Skip whitespace. */
1543 while (*p == ' ' || *p == '\t' || *p == '\n')
1545 if (*p == ':' && p[1] == ':')
1547 /* Skip the `::'. */
1549 /* Skip whitespace. */
1550 while (*p == ' ' || *p == '\t' || *p == '\n')
1553 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1554 || (*p >= 'a' && *p <= 'z')
1555 || (*p >= 'A' && *p <= 'Z'))
1559 struct symbol *cur_sym;
1560 /* As big as the whole rest of the expression, which is
1561 at least big enough. */
1562 char *tmp = alloca (strlen (namestart));
1564 memcpy (tmp, namestart, p - namestart);
1565 tmp[p - namestart] = '\0';
1566 cur_sym = lookup_symbol (tmp, expression_context_block,
1567 VAR_NAMESPACE, (int *) NULL,
1568 (struct symtab **) NULL);
1571 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1589 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1591 yylval.tsym.type = SYMBOL_TYPE (sym);
1595 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1598 /* Input names that aren't symbols but ARE valid hex numbers,
1599 when the input radix permits them, can be names or numbers
1600 depending on the parse. Note we support radixes > 16 here. */
1602 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1603 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1605 YYSTYPE newlval; /* Its value is ignored. */
1606 hextype = parse_number (tokstart, namelen, 0, &newlval);
1609 yylval.ssym.sym = sym;
1610 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1615 /* Any other kind of symbol */
1616 yylval.ssym.sym = sym;
1617 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1626 error (msg ? msg : "Invalid syntax in expression.");