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"
41 #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_elt_opcode (OP_LONG);
639 write_exp_elt_type (builtin_type_long);
640 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
641 write_exp_elt_opcode (OP_LONG);
642 write_exp_elt_opcode (UNOP_MEMVAL);
643 if (msymbol -> type == mst_data ||
644 msymbol -> type == mst_bss)
645 write_exp_elt_type (builtin_type_int);
646 else if (msymbol -> type == mst_text)
647 write_exp_elt_type (lookup_function_type (builtin_type_int));
649 write_exp_elt_type (builtin_type_char);
650 write_exp_elt_opcode (UNOP_MEMVAL);
653 if (!have_full_symbols () && !have_partial_symbols ())
654 error ("No symbol table is loaded. Use the \"file\" command.");
656 error ("No symbol \"%s\" in current context.", name);
660 variable: name_not_typename
661 { struct symbol *sym = $1.sym;
665 if (symbol_read_needs_frame (sym))
667 if (innermost_block == 0 ||
668 contained_in (block_found,
670 innermost_block = block_found;
673 write_exp_elt_opcode (OP_VAR_VALUE);
674 /* We want to use the selected frame, not
675 another more inner frame which happens to
676 be in the same block. */
677 write_exp_elt_block (NULL);
678 write_exp_elt_sym (sym);
679 write_exp_elt_opcode (OP_VAR_VALUE);
681 else if ($1.is_a_field_of_this)
683 /* C++: it hangs off of `this'. Must
684 not inadvertently convert from a method call
686 if (innermost_block == 0 ||
687 contained_in (block_found, innermost_block))
688 innermost_block = block_found;
689 write_exp_elt_opcode (OP_THIS);
690 write_exp_elt_opcode (OP_THIS);
691 write_exp_elt_opcode (STRUCTOP_PTR);
692 write_exp_string ($1.stoken);
693 write_exp_elt_opcode (STRUCTOP_PTR);
697 struct minimal_symbol *msymbol;
698 register char *arg = copy_name ($1.stoken);
700 msymbol = lookup_minimal_symbol (arg,
701 (struct objfile *) NULL);
704 write_exp_elt_opcode (OP_LONG);
705 write_exp_elt_type (builtin_type_long);
706 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
707 write_exp_elt_opcode (OP_LONG);
708 write_exp_elt_opcode (UNOP_MEMVAL);
709 if (msymbol -> type == mst_data ||
710 msymbol -> type == mst_bss)
711 write_exp_elt_type (builtin_type_int);
712 else if (msymbol -> type == mst_text)
713 write_exp_elt_type (lookup_function_type (builtin_type_int));
715 write_exp_elt_type (builtin_type_char);
716 write_exp_elt_opcode (UNOP_MEMVAL);
718 else if (!have_full_symbols () && !have_partial_symbols ())
719 error ("No symbol table is loaded. Use the \"file\" command.");
721 error ("No symbol \"%s\" in current context.",
722 copy_name ($1.stoken));
729 /* "const" and "volatile" are curently ignored. A type qualifier
730 before the type is currently handled in the typebase rule.
731 The reason for recognizing these here (shift/reduce conflicts)
732 might be obsolete now that some pointer to member rules have
734 | typebase CONST_KEYWORD
735 | typebase VOLATILE_KEYWORD
737 { $$ = follow_types ($1); }
738 | typebase CONST_KEYWORD abs_decl
739 { $$ = follow_types ($1); }
740 | typebase VOLATILE_KEYWORD abs_decl
741 { $$ = follow_types ($1); }
745 { push_type (tp_pointer); $$ = 0; }
747 { push_type (tp_pointer); $$ = $2; }
749 { push_type (tp_reference); $$ = 0; }
751 { push_type (tp_reference); $$ = $2; }
755 direct_abs_decl: '(' abs_decl ')'
757 | direct_abs_decl array_mod
760 push_type (tp_array);
765 push_type (tp_array);
769 | direct_abs_decl func_mod
770 { push_type (tp_function); }
772 { push_type (tp_function); }
783 | '(' nonempty_typelist ')'
784 { free ((PTR)$2); $$ = 0; }
787 /* We used to try to recognize more pointer to member types here, but
788 that didn't work (shift/reduce conflicts meant that these rules never
789 got executed). The problem is that
790 int (foo::bar::baz::bizzle)
791 is a function type but
792 int (foo::bar::baz::bizzle::*)
793 is a pointer to member type. Stroustrup loses again! */
796 | typebase COLONCOLON '*'
797 { $$ = lookup_member_type (builtin_type_int, $1); }
800 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
804 { $$ = builtin_type_int; }
806 { $$ = builtin_type_long; }
808 { $$ = builtin_type_short; }
810 { $$ = builtin_type_long; }
811 | UNSIGNED LONG INT_KEYWORD
812 { $$ = builtin_type_unsigned_long; }
814 { $$ = builtin_type_long_long; }
815 | LONG LONG INT_KEYWORD
816 { $$ = builtin_type_long_long; }
818 { $$ = builtin_type_unsigned_long_long; }
819 | UNSIGNED LONG LONG INT_KEYWORD
820 { $$ = builtin_type_unsigned_long_long; }
822 { $$ = builtin_type_short; }
823 | UNSIGNED SHORT INT_KEYWORD
824 { $$ = builtin_type_unsigned_short; }
826 { $$ = lookup_struct (copy_name ($2),
827 expression_context_block); }
829 { $$ = lookup_struct (copy_name ($2),
830 expression_context_block); }
832 { $$ = lookup_union (copy_name ($2),
833 expression_context_block); }
835 { $$ = lookup_enum (copy_name ($2),
836 expression_context_block); }
838 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
840 { $$ = builtin_type_unsigned_int; }
841 | SIGNED_KEYWORD typename
842 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
844 { $$ = builtin_type_int; }
845 | TEMPLATE name '<' type '>'
846 { $$ = lookup_template_type(copy_name($2), $4,
847 expression_context_block);
849 /* "const" and "volatile" are curently ignored. A type qualifier
850 after the type is handled in the ptype rule. I think these could
852 | CONST_KEYWORD typebase { $$ = $2; }
853 | VOLATILE_KEYWORD typebase { $$ = $2; }
859 $$.stoken.ptr = "int";
860 $$.stoken.length = 3;
861 $$.type = builtin_type_int;
865 $$.stoken.ptr = "long";
866 $$.stoken.length = 4;
867 $$.type = builtin_type_long;
871 $$.stoken.ptr = "short";
872 $$.stoken.length = 5;
873 $$.type = builtin_type_short;
879 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
880 $<ivec>$[0] = 1; /* Number of types in vector */
883 | nonempty_typelist ',' type
884 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
885 $$ = (struct type **) realloc ((char *) $1, len);
886 $$[$<ivec>$[0]] = $3;
890 name : NAME { $$ = $1.stoken; }
891 | BLOCKNAME { $$ = $1.stoken; }
892 | TYPENAME { $$ = $1.stoken; }
893 | NAME_OR_INT { $$ = $1.stoken; }
896 name_not_typename : NAME
898 /* These would be useful if name_not_typename was useful, but it is just
899 a fake for "variable", so these cause reduce/reduce conflicts because
900 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
901 =exp) or just an exp. If name_not_typename was ever used in an lvalue
902 context where only a name could occur, this might be useful.
909 /* Take care of parsing a number (anything that starts with a digit).
910 Set yylval and return the token type; update lexptr.
911 LEN is the number of characters in it. */
913 /*** Needs some error checking for the float case ***/
916 parse_number (p, len, parsed_float, putithere)
922 register LONGEST n = 0;
923 register LONGEST prevn = 0;
926 register int base = input_radix;
929 unsigned LONGEST high_bit;
930 struct type *signed_type;
931 struct type *unsigned_type;
935 /* It's a float since it contains a point or an exponent. */
936 putithere->dval = atof (p);
940 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
974 if (c >= 'A' && c <= 'Z')
976 if (c != 'l' && c != 'u')
978 if (c >= '0' && c <= '9')
982 if (base > 10 && c >= 'a' && c <= 'f')
983 n += i = c - 'a' + 10;
984 else if (len == 0 && c == 'l')
986 else if (len == 0 && c == 'u')
989 return ERROR; /* Char not a digit */
992 return ERROR; /* Invalid digit in this base */
994 /* Portably test for overflow (only works for nonzero values, so make
995 a second check for zero). */
996 if((prevn >= n) && n != 0)
997 unsigned_p=1; /* Try something unsigned */
998 /* If range checking enabled, portably test for unsigned overflow. */
999 if(RANGE_CHECK && n!=0)
1001 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1002 range_error("Overflow on numeric constant.");
1007 /* If the number is too big to be an int, or it's got an l suffix
1008 then it's a long. Work out if this has to be a long by
1009 shifting right and and seeing if anything remains, and the
1010 target int size is different to the target long size.
1012 In the expression below, we could have tested
1013 (n >> TARGET_INT_BIT)
1014 to see if it was zero,
1015 but too many compilers warn about that, when ints and longs
1016 are the same size. So we shift it twice, with fewer bits
1017 each time, for the same result. */
1019 if ( (TARGET_INT_BIT != TARGET_LONG_BIT
1020 && ((n >> 2) >> (TARGET_INT_BIT-2))) /* Avoid shift warning */
1023 high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1024 unsigned_type = builtin_type_unsigned_long;
1025 signed_type = builtin_type_long;
1029 high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1030 unsigned_type = builtin_type_unsigned_int;
1031 signed_type = builtin_type_int;
1034 putithere->typed_val.val = n;
1036 /* If the high bit of the worked out type is set then this number
1037 has to be unsigned. */
1039 if (unsigned_p || (n & high_bit))
1041 putithere->typed_val.type = unsigned_type;
1045 putithere->typed_val.type = signed_type;
1055 enum exp_opcode opcode;
1058 static const struct token tokentab3[] =
1060 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1061 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1064 static const struct token tokentab2[] =
1066 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1067 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1068 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1069 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1070 {"%=", ASSIGN_MODIFY, BINOP_REM},
1071 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1072 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1073 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1074 {"++", INCREMENT, BINOP_END},
1075 {"--", DECREMENT, BINOP_END},
1076 {"->", ARROW, BINOP_END},
1077 {"&&", ANDAND, BINOP_END},
1078 {"||", OROR, BINOP_END},
1079 {"::", COLONCOLON, BINOP_END},
1080 {"<<", LSH, BINOP_END},
1081 {">>", RSH, BINOP_END},
1082 {"==", EQUAL, BINOP_END},
1083 {"!=", NOTEQUAL, BINOP_END},
1084 {"<=", LEQ, BINOP_END},
1085 {">=", GEQ, BINOP_END}
1088 /* Read one token, getting characters through lexptr. */
1099 static char *tempbuf;
1100 static int tempbufsize;
1105 /* See if it is a special token of length 3. */
1106 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1107 if (STREQN (tokstart, tokentab3[i].operator, 3))
1110 yylval.opcode = tokentab3[i].opcode;
1111 return tokentab3[i].token;
1114 /* See if it is a special token of length 2. */
1115 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1116 if (STREQN (tokstart, tokentab2[i].operator, 2))
1119 yylval.opcode = tokentab2[i].opcode;
1120 return tokentab2[i].token;
1123 switch (c = *tokstart)
1135 /* We either have a character constant ('0' or '\177' for example)
1136 or we have a quoted symbol reference ('foo(int,int)' in C++
1141 c = parse_escape (&lexptr);
1143 yylval.typed_val.val = c;
1144 yylval.typed_val.type = builtin_type_char;
1149 namelen = skip_quoted (tokstart) - tokstart;
1152 lexptr = tokstart + namelen;
1153 if (lexptr[-1] != '\'')
1154 error ("Unmatched single quote.");
1159 error ("Invalid character constant.");
1169 if (paren_depth == 0)
1176 if (comma_terminates && paren_depth == 0)
1182 /* Might be a floating point number. */
1183 if (lexptr[1] < '0' || lexptr[1] > '9')
1184 goto symbol; /* Nope, must be a symbol. */
1185 /* FALL THRU into number case. */
1198 /* It's a number. */
1199 int got_dot = 0, got_e = 0, toktype;
1200 register char *p = tokstart;
1201 int hex = input_radix > 10;
1203 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1208 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1216 /* This test includes !hex because 'e' is a valid hex digit
1217 and thus does not indicate a floating point number when
1218 the radix is hex. */
1219 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1220 got_dot = got_e = 1;
1221 /* This test does not include !hex, because a '.' always indicates
1222 a decimal floating point number regardless of the radix. */
1223 else if (!got_dot && *p == '.')
1225 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1226 && (*p == '-' || *p == '+'))
1227 /* This is the sign of the exponent, not the end of the
1230 /* We will take any letters or digits. parse_number will
1231 complain if past the radix, or if L or U are not final. */
1232 else if ((*p < '0' || *p > '9')
1233 && ((*p < 'a' || *p > 'z')
1234 && (*p < 'A' || *p > 'Z')))
1237 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1238 if (toktype == ERROR)
1240 char *err_copy = (char *) alloca (p - tokstart + 1);
1242 memcpy (err_copy, tokstart, p - tokstart);
1243 err_copy[p - tokstart] = 0;
1244 error ("Invalid number \"%s\".", err_copy);
1276 /* Build the gdb internal form of the input string in tempbuf,
1277 translating any standard C escape forms seen. Note that the
1278 buffer is null byte terminated *only* for the convenience of
1279 debugging gdb itself and printing the buffer contents when
1280 the buffer contains no embedded nulls. Gdb does not depend
1281 upon the buffer being null byte terminated, it uses the length
1282 string instead. This allows gdb to handle C strings (as well
1283 as strings in other languages) with embedded null bytes */
1285 tokptr = ++tokstart;
1289 /* Grow the static temp buffer if necessary, including allocating
1290 the first one on demand. */
1291 if (tempbufindex + 1 >= tempbufsize)
1293 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1299 /* Do nothing, loop will terminate. */
1303 c = parse_escape (&tokptr);
1308 tempbuf[tempbufindex++] = c;
1311 tempbuf[tempbufindex++] = *tokptr++;
1314 } while ((*tokptr != '"') && (*tokptr != '\0'));
1315 if (*tokptr++ != '"')
1317 error ("Unterminated string in expression.");
1319 tempbuf[tempbufindex] = '\0'; /* See note above */
1320 yylval.sval.ptr = tempbuf;
1321 yylval.sval.length = tempbufindex;
1326 if (!(c == '_' || c == '$'
1327 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1328 /* We must have come across a bad character (e.g. ';'). */
1329 error ("Invalid character '%c' in expression.", c);
1331 /* It's a name. See how long it is. */
1333 for (c = tokstart[namelen];
1334 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1335 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1336 c = tokstart[++namelen])
1339 /* The token "if" terminates the expression and is NOT
1340 removed from the input stream. */
1341 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1348 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1349 and $$digits (equivalent to $<-digits> if you could type that).
1350 Make token type LAST, and put the number (the digits) in yylval. */
1353 if (*tokstart == '$')
1355 register int negate = 0;
1357 /* Double dollar means negate the number and add -1 as well.
1358 Thus $$ alone means -1. */
1359 if (namelen >= 2 && tokstart[1] == '$')
1366 /* Just dollars (one or two) */
1367 yylval.lval = - negate;
1370 /* Is the rest of the token digits? */
1371 for (; c < namelen; c++)
1372 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1376 yylval.lval = atoi (tokstart + 1 + negate);
1378 yylval.lval = - yylval.lval;
1383 /* Handle tokens that refer to machine registers:
1384 $ followed by a register name. */
1386 if (*tokstart == '$') {
1387 for (c = 0; c < NUM_REGS; c++)
1388 if (namelen - 1 == strlen (reg_names[c])
1389 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1394 for (c = 0; c < num_std_regs; c++)
1395 if (namelen - 1 == strlen (std_regs[c].name)
1396 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1398 yylval.lval = std_regs[c].regnum;
1402 /* Catch specific keywords. Should be done with a data structure. */
1406 if (STREQN (tokstart, "unsigned", 8))
1408 if (current_language->la_language == language_cplus
1409 && STREQN (tokstart, "template", 8))
1411 if (STREQN (tokstart, "volatile", 8))
1412 return VOLATILE_KEYWORD;
1415 if (STREQN (tokstart, "struct", 6))
1417 if (STREQN (tokstart, "signed", 6))
1418 return SIGNED_KEYWORD;
1419 if (STREQN (tokstart, "sizeof", 6))
1423 if (current_language->la_language == language_cplus
1424 && STREQN (tokstart, "class", 5))
1426 if (STREQN (tokstart, "union", 5))
1428 if (STREQN (tokstart, "short", 5))
1430 if (STREQN (tokstart, "const", 5))
1431 return CONST_KEYWORD;
1434 if (STREQN (tokstart, "enum", 4))
1436 if (STREQN (tokstart, "long", 4))
1438 if (current_language->la_language == language_cplus
1439 && STREQN (tokstart, "this", 4))
1441 static const char this_name[] =
1442 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1444 if (lookup_symbol (this_name, expression_context_block,
1445 VAR_NAMESPACE, (int *) NULL,
1446 (struct symtab **) NULL))
1451 if (STREQN (tokstart, "int", 3))
1458 yylval.sval.ptr = tokstart;
1459 yylval.sval.length = namelen;
1461 /* Any other names starting in $ are debugger internal variables. */
1463 if (*tokstart == '$')
1465 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1469 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1470 functions or symtabs. If this is not so, then ...
1471 Use token-type TYPENAME for symbols that happen to be defined
1472 currently as names of types; NAME for other symbols.
1473 The caller is not constrained to care about the distinction. */
1475 char *tmp = copy_name (yylval.sval);
1477 int is_a_field_of_this = 0;
1480 sym = lookup_symbol (tmp, expression_context_block,
1482 current_language->la_language == language_cplus
1483 ? &is_a_field_of_this : (int *) NULL,
1484 (struct symtab **) NULL);
1485 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1486 lookup_partial_symtab (tmp))
1488 yylval.ssym.sym = sym;
1489 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1492 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1496 struct symbol *best_sym;
1498 /* Look ahead to detect nested types. This probably should be
1499 done in the grammar, but trying seemed to introduce a lot
1500 of shift/reduce and reduce/reduce conflicts. It's possible
1501 that it could be done, though. Or perhaps a non-grammar, but
1502 less ad hoc, approach would work well. */
1504 /* Since we do not currently have any way of distinguishing
1505 a nested type from a non-nested one (the stabs don't tell
1506 us whether a type is nested), we just ignore the
1513 /* Skip whitespace. */
1514 while (*p == ' ' || *p == '\t' || *p == '\n')
1516 if (*p == ':' && p[1] == ':')
1518 /* Skip the `::'. */
1520 /* Skip whitespace. */
1521 while (*p == ' ' || *p == '\t' || *p == '\n')
1524 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1525 || (*p >= 'a' && *p <= 'z')
1526 || (*p >= 'A' && *p <= 'Z'))
1530 struct symbol *cur_sym;
1531 /* As big as the whole rest of the expression, which is
1532 at least big enough. */
1533 char *tmp = alloca (strlen (namestart));
1535 memcpy (tmp, namestart, p - namestart);
1536 tmp[p - namestart] = '\0';
1537 cur_sym = lookup_symbol (tmp, expression_context_block,
1538 VAR_NAMESPACE, (int *) NULL,
1539 (struct symtab **) NULL);
1542 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1560 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1563 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1566 /* Input names that aren't symbols but ARE valid hex numbers,
1567 when the input radix permits them, can be names or numbers
1568 depending on the parse. Note we support radixes > 16 here. */
1570 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1571 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1573 YYSTYPE newlval; /* Its value is ignored. */
1574 hextype = parse_number (tokstart, namelen, 0, &newlval);
1577 yylval.ssym.sym = sym;
1578 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1583 /* Any other kind of symbol */
1584 yylval.ssym.sym = sym;
1585 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1594 error (msg ? msg : "Invalid syntax in expression.");