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"
46 /* These MUST be included in any grammar file!!!! Please choose unique names!
47 Note that this are a combined list of variables that can be produced
48 by any one of bison, byacc, or yacc. */
49 #define yymaxdepth c_maxdepth
50 #define yyparse c_parse
52 #define yyerror c_error
55 #define yydebug c_debug
64 #define yyerrflag c_errflag
65 #define yynerrs c_nerrs
70 #define yystate c_state
76 #define yyrule c_rule /* With YYDEBUG defined, byacc */
77 #define yyname c_name /* With YYDEBUG defined, byacc */
78 #define yyreds c_reds /* With YYDEBUG defined */
79 #define yytoks c_toks /* With YYDEBUG defined */
80 #define yyss c_yyss /* byacc */
81 #define yyssp c_yysp /* byacc */
82 #define yyvs c_yyvs /* byacc */
83 #define yyvsp c_yyvsp /* byacc */
86 yyparse PARAMS ((void));
89 yylex PARAMS ((void));
92 yyerror PARAMS ((char *));
100 /* Although the yacc "value" of an expression is not used,
101 since the result is stored in the structure being created,
102 other node types do have values. */
107 unsigned LONGEST ulval;
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
134 %type <tval> type typebase
135 %type <tvec> nonempty_typelist
136 /* %type <bval> block */
138 /* Fancy type parsing. */
139 %type <voidval> func_mod direct_abs_decl abs_decl
141 %type <lval> array_mod
143 %token <typed_val> INT
146 /* Both NAME and TYPENAME tokens represent symbols in the input,
147 and both convey their data as strings.
148 But a TYPENAME is a string that happens to be defined as a typedef
149 or builtin type name (such as int or char)
150 and a NAME is any other symbol.
151 Contexts where this distinction is not important can use the
152 nonterminal "name", which matches either NAME or TYPENAME. */
155 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
156 %token <tsym> TYPENAME
158 %type <ssym> name_not_typename
159 %type <tsym> typename
161 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
162 but which would parse as a valid number in the current input radix.
163 E.g. "c" when input_radix==16. Depending on the parse, it will be
164 turned into a name or into a number. */
166 %token <ssym> NAME_OR_INT
168 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
172 /* Special type cases, put in to allow the parser to distinguish different
174 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
175 %token <lval> LAST REGNAME
177 %token <ivar> VARIABLE
179 %token <opcode> ASSIGN_MODIFY
186 %right '=' ASSIGN_MODIFY
194 %left '<' '>' LEQ GEQ
199 %right UNARY INCREMENT DECREMENT
200 %right ARROW '.' '[' '('
201 %token <ssym> BLOCKNAME
213 { write_exp_elt_opcode(OP_TYPE);
214 write_exp_elt_type($1);
215 write_exp_elt_opcode(OP_TYPE);}
218 /* Expressions, including the comma operator. */
221 { write_exp_elt_opcode (BINOP_COMMA); }
224 /* Expressions, not including the comma operator. */
225 exp : '*' exp %prec UNARY
226 { write_exp_elt_opcode (UNOP_IND); }
228 exp : '&' exp %prec UNARY
229 { write_exp_elt_opcode (UNOP_ADDR); }
231 exp : '-' exp %prec UNARY
232 { write_exp_elt_opcode (UNOP_NEG); }
235 exp : '!' exp %prec UNARY
236 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
239 exp : '~' exp %prec UNARY
240 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
243 exp : INCREMENT exp %prec UNARY
244 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
247 exp : DECREMENT exp %prec UNARY
248 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
251 exp : exp INCREMENT %prec UNARY
252 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
255 exp : exp DECREMENT %prec UNARY
256 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
259 exp : SIZEOF exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_SIZEOF); }
264 { write_exp_elt_opcode (STRUCTOP_PTR);
265 write_exp_string ($3);
266 write_exp_elt_opcode (STRUCTOP_PTR); }
269 exp : exp ARROW qualified_name
270 { /* exp->type::name becomes exp->*(&type::name) */
271 /* Note: this doesn't work if name is a
272 static member! FIXME */
273 write_exp_elt_opcode (UNOP_ADDR);
274 write_exp_elt_opcode (STRUCTOP_MPTR); }
276 exp : exp ARROW '*' exp
277 { write_exp_elt_opcode (STRUCTOP_MPTR); }
281 { write_exp_elt_opcode (STRUCTOP_STRUCT);
282 write_exp_string ($3);
283 write_exp_elt_opcode (STRUCTOP_STRUCT); }
286 exp : exp '.' qualified_name
287 { /* exp.type::name becomes exp.*(&type::name) */
288 /* Note: this doesn't work if name is a
289 static member! FIXME */
290 write_exp_elt_opcode (UNOP_ADDR);
291 write_exp_elt_opcode (STRUCTOP_MEMBER); }
294 exp : exp '.' '*' exp
295 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
298 exp : exp '[' exp1 ']'
299 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
303 /* This is to save the value of arglist_len
304 being accumulated by an outer function call. */
305 { start_arglist (); }
306 arglist ')' %prec ARROW
307 { write_exp_elt_opcode (OP_FUNCALL);
308 write_exp_elt_longcst ((LONGEST) end_arglist ());
309 write_exp_elt_opcode (OP_FUNCALL); }
319 arglist : arglist ',' exp %prec ABOVE_COMMA
323 exp : '{' type '}' exp %prec UNARY
324 { write_exp_elt_opcode (UNOP_MEMVAL);
325 write_exp_elt_type ($2);
326 write_exp_elt_opcode (UNOP_MEMVAL); }
329 exp : '(' type ')' exp %prec UNARY
330 { write_exp_elt_opcode (UNOP_CAST);
331 write_exp_elt_type ($2);
332 write_exp_elt_opcode (UNOP_CAST); }
339 /* Binary operators in order of decreasing precedence. */
342 { write_exp_elt_opcode (BINOP_REPEAT); }
346 { write_exp_elt_opcode (BINOP_MUL); }
350 { write_exp_elt_opcode (BINOP_DIV); }
354 { write_exp_elt_opcode (BINOP_REM); }
358 { write_exp_elt_opcode (BINOP_ADD); }
362 { write_exp_elt_opcode (BINOP_SUB); }
366 { write_exp_elt_opcode (BINOP_LSH); }
370 { write_exp_elt_opcode (BINOP_RSH); }
374 { write_exp_elt_opcode (BINOP_EQUAL); }
377 exp : exp NOTEQUAL exp
378 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
382 { write_exp_elt_opcode (BINOP_LEQ); }
386 { write_exp_elt_opcode (BINOP_GEQ); }
390 { write_exp_elt_opcode (BINOP_LESS); }
394 { write_exp_elt_opcode (BINOP_GTR); }
398 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
402 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
406 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
410 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
414 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
417 exp : exp '?' exp ':' exp %prec '?'
418 { write_exp_elt_opcode (TERNOP_COND); }
422 { write_exp_elt_opcode (BINOP_ASSIGN); }
425 exp : exp ASSIGN_MODIFY exp
426 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
427 write_exp_elt_opcode ($2);
428 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
432 { write_exp_elt_opcode (OP_LONG);
433 write_exp_elt_type ($1.type);
434 write_exp_elt_longcst ((LONGEST)($1.val));
435 write_exp_elt_opcode (OP_LONG); }
440 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
441 write_exp_elt_opcode (OP_LONG);
442 write_exp_elt_type (val.typed_val.type);
443 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
444 write_exp_elt_opcode (OP_LONG);
450 { write_exp_elt_opcode (OP_DOUBLE);
451 write_exp_elt_type (builtin_type_double);
452 write_exp_elt_dblcst ($1);
453 write_exp_elt_opcode (OP_DOUBLE); }
460 { write_exp_elt_opcode (OP_LAST);
461 write_exp_elt_longcst ((LONGEST) $1);
462 write_exp_elt_opcode (OP_LAST); }
466 { write_exp_elt_opcode (OP_REGISTER);
467 write_exp_elt_longcst ((LONGEST) $1);
468 write_exp_elt_opcode (OP_REGISTER); }
472 { write_exp_elt_opcode (OP_INTERNALVAR);
473 write_exp_elt_intern ($1);
474 write_exp_elt_opcode (OP_INTERNALVAR); }
477 exp : SIZEOF '(' type ')' %prec UNARY
478 { write_exp_elt_opcode (OP_LONG);
479 write_exp_elt_type (builtin_type_int);
480 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
481 write_exp_elt_opcode (OP_LONG); }
485 { write_exp_elt_opcode (OP_STRING);
486 write_exp_string ($1);
487 write_exp_elt_opcode (OP_STRING); }
492 { write_exp_elt_opcode (OP_THIS);
493 write_exp_elt_opcode (OP_THIS); }
501 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
505 lookup_symtab (copy_name ($1.stoken));
507 $$ = BLOCKVECTOR_BLOCK
508 (BLOCKVECTOR (tem), STATIC_BLOCK);
510 error ("No file or function \"%s\".",
511 copy_name ($1.stoken));
516 block : block COLONCOLON name
518 = lookup_symbol (copy_name ($3), $1,
519 VAR_NAMESPACE, 0, NULL);
520 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
521 error ("No function \"%s\" in specified context.",
523 $$ = SYMBOL_BLOCK_VALUE (tem); }
526 variable: block COLONCOLON name
527 { struct symbol *sym;
528 sym = lookup_symbol (copy_name ($3), $1,
529 VAR_NAMESPACE, 0, NULL);
531 error ("No symbol \"%s\" in specified context.",
534 write_exp_elt_opcode (OP_VAR_VALUE);
535 write_exp_elt_sym (sym);
536 write_exp_elt_opcode (OP_VAR_VALUE); }
539 qualified_name: typebase COLONCOLON name
541 struct type *type = $1;
542 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
543 && TYPE_CODE (type) != TYPE_CODE_UNION)
544 error ("`%s' is not defined as an aggregate type.",
547 write_exp_elt_opcode (OP_SCOPE);
548 write_exp_elt_type (type);
549 write_exp_string ($3);
550 write_exp_elt_opcode (OP_SCOPE);
552 | typebase COLONCOLON '~' name
554 struct type *type = $1;
555 struct stoken tmp_token;
556 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
557 && TYPE_CODE (type) != TYPE_CODE_UNION)
558 error ("`%s' is not defined as an aggregate type.",
561 if (!STREQ (type_name_no_tag (type), $4.ptr))
562 error ("invalid destructor `%s::~%s'",
563 type_name_no_tag (type), $4.ptr);
565 tmp_token.ptr = (char*) alloca ($4.length + 2);
566 tmp_token.length = $4.length + 1;
567 tmp_token.ptr[0] = '~';
568 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
569 tmp_token.ptr[tmp_token.length] = 0;
570 write_exp_elt_opcode (OP_SCOPE);
571 write_exp_elt_type (type);
572 write_exp_string (tmp_token);
573 write_exp_elt_opcode (OP_SCOPE);
577 variable: qualified_name
580 char *name = copy_name ($2);
582 struct minimal_symbol *msymbol;
585 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
588 write_exp_elt_opcode (OP_VAR_VALUE);
589 write_exp_elt_sym (sym);
590 write_exp_elt_opcode (OP_VAR_VALUE);
594 msymbol = lookup_minimal_symbol (name,
595 (struct objfile *) NULL);
598 write_exp_elt_opcode (OP_LONG);
599 write_exp_elt_type (builtin_type_int);
600 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
601 write_exp_elt_opcode (OP_LONG);
602 write_exp_elt_opcode (UNOP_MEMVAL);
603 if (msymbol -> type == mst_data ||
604 msymbol -> type == mst_bss)
605 write_exp_elt_type (builtin_type_int);
606 else if (msymbol -> type == mst_text)
607 write_exp_elt_type (lookup_function_type (builtin_type_int));
609 write_exp_elt_type (builtin_type_char);
610 write_exp_elt_opcode (UNOP_MEMVAL);
613 if (!have_full_symbols () && !have_partial_symbols ())
614 error ("No symbol table is loaded. Use the \"file\" command.");
616 error ("No symbol \"%s\" in current context.", name);
620 variable: name_not_typename
621 { struct symbol *sym = $1.sym;
625 switch (SYMBOL_CLASS (sym))
633 if (innermost_block == 0 ||
634 contained_in (block_found,
636 innermost_block = block_found;
643 case LOC_CONST_BYTES:
645 /* In this case the expression can
646 be evaluated regardless of what
647 frame we are in, so there is no
648 need to check for the
649 innermost_block. These cases are
650 listed so that gcc -Wall will
651 report types that may not have
656 write_exp_elt_opcode (OP_VAR_VALUE);
657 write_exp_elt_sym (sym);
658 write_exp_elt_opcode (OP_VAR_VALUE);
660 else if ($1.is_a_field_of_this)
662 /* C++: it hangs off of `this'. Must
663 not inadvertently convert from a method call
665 if (innermost_block == 0 ||
666 contained_in (block_found, innermost_block))
667 innermost_block = block_found;
668 write_exp_elt_opcode (OP_THIS);
669 write_exp_elt_opcode (OP_THIS);
670 write_exp_elt_opcode (STRUCTOP_PTR);
671 write_exp_string ($1.stoken);
672 write_exp_elt_opcode (STRUCTOP_PTR);
676 struct minimal_symbol *msymbol;
677 register char *arg = copy_name ($1.stoken);
679 msymbol = lookup_minimal_symbol (arg,
680 (struct objfile *) NULL);
683 write_exp_elt_opcode (OP_LONG);
684 write_exp_elt_type (builtin_type_int);
685 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
686 write_exp_elt_opcode (OP_LONG);
687 write_exp_elt_opcode (UNOP_MEMVAL);
688 if (msymbol -> type == mst_data ||
689 msymbol -> type == mst_bss)
690 write_exp_elt_type (builtin_type_int);
691 else if (msymbol -> type == mst_text)
692 write_exp_elt_type (lookup_function_type (builtin_type_int));
694 write_exp_elt_type (builtin_type_char);
695 write_exp_elt_opcode (UNOP_MEMVAL);
697 else if (!have_full_symbols () && !have_partial_symbols ())
698 error ("No symbol table is loaded. Use the \"file\" command.");
700 error ("No symbol \"%s\" in current context.",
701 copy_name ($1.stoken));
710 /* This is where the interesting stuff happens. */
713 struct type *follow_type = $1;
714 struct type *range_type;
723 follow_type = lookup_pointer_type (follow_type);
726 follow_type = lookup_reference_type (follow_type);
729 array_size = pop_type_int ();
730 if (array_size != -1)
733 create_range_type ((struct type *) NULL,
737 create_array_type ((struct type *) NULL,
738 follow_type, range_type);
741 follow_type = lookup_pointer_type (follow_type);
744 follow_type = lookup_function_type (follow_type);
752 { push_type (tp_pointer); $$ = 0; }
754 { push_type (tp_pointer); $$ = $2; }
756 { push_type (tp_reference); $$ = 0; }
758 { push_type (tp_reference); $$ = $2; }
762 direct_abs_decl: '(' abs_decl ')'
764 | direct_abs_decl array_mod
767 push_type (tp_array);
772 push_type (tp_array);
775 | direct_abs_decl func_mod
776 { push_type (tp_function); }
778 { push_type (tp_function); }
789 | '(' nonempty_typelist ')'
790 { free ((PTR)$2); $$ = 0; }
794 | typebase COLONCOLON '*'
795 { $$ = lookup_member_type (builtin_type_int, $1); }
796 | type '(' typebase COLONCOLON '*' ')'
797 { $$ = lookup_member_type ($1, $3); }
798 | type '(' typebase COLONCOLON '*' ')' '(' ')'
799 { $$ = lookup_member_type
800 (lookup_function_type ($1), $3); }
801 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
802 { $$ = lookup_member_type
803 (lookup_function_type ($1), $3);
807 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
811 { $$ = builtin_type_int; }
813 { $$ = builtin_type_long; }
815 { $$ = builtin_type_short; }
817 { $$ = builtin_type_long; }
818 | UNSIGNED LONG INT_KEYWORD
819 { $$ = builtin_type_unsigned_long; }
821 { $$ = builtin_type_long_long; }
822 | LONG LONG INT_KEYWORD
823 { $$ = builtin_type_long_long; }
825 { $$ = builtin_type_unsigned_long_long; }
826 | UNSIGNED LONG LONG INT_KEYWORD
827 { $$ = builtin_type_unsigned_long_long; }
829 { $$ = builtin_type_short; }
830 | UNSIGNED SHORT INT_KEYWORD
831 { $$ = builtin_type_unsigned_short; }
833 { $$ = lookup_struct (copy_name ($2),
834 expression_context_block); }
836 { $$ = lookup_struct (copy_name ($2),
837 expression_context_block); }
839 { $$ = lookup_union (copy_name ($2),
840 expression_context_block); }
842 { $$ = lookup_enum (copy_name ($2),
843 expression_context_block); }
845 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
847 { $$ = builtin_type_unsigned_int; }
848 | SIGNED_KEYWORD typename
849 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
851 { $$ = builtin_type_int; }
852 | TEMPLATE name '<' type '>'
853 { $$ = lookup_template_type(copy_name($2), $4,
854 expression_context_block);
856 /* "const" and "volatile" are curently ignored. */
857 | CONST_KEYWORD typebase { $$ = $2; }
858 | VOLATILE_KEYWORD typebase { $$ = $2; }
864 $$.stoken.ptr = "int";
865 $$.stoken.length = 3;
866 $$.type = builtin_type_int;
870 $$.stoken.ptr = "long";
871 $$.stoken.length = 4;
872 $$.type = builtin_type_long;
876 $$.stoken.ptr = "short";
877 $$.stoken.length = 5;
878 $$.type = builtin_type_short;
884 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
885 $<ivec>$[0] = 1; /* Number of types in vector */
888 | nonempty_typelist ',' type
889 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
890 $$ = (struct type **) realloc ((char *) $1, len);
891 $$[$<ivec>$[0]] = $3;
895 name : NAME { $$ = $1.stoken; }
896 | BLOCKNAME { $$ = $1.stoken; }
897 | TYPENAME { $$ = $1.stoken; }
898 | NAME_OR_INT { $$ = $1.stoken; }
901 name_not_typename : NAME
903 /* These would be useful if name_not_typename was useful, but it is just
904 a fake for "variable", so these cause reduce/reduce conflicts because
905 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
906 =exp) or just an exp. If name_not_typename was ever used in an lvalue
907 context where only a name could occur, this might be useful.
914 /* Take care of parsing a number (anything that starts with a digit).
915 Set yylval and return the token type; update lexptr.
916 LEN is the number of characters in it. */
918 /*** Needs some error checking for the float case ***/
921 parse_number (p, len, parsed_float, putithere)
927 register LONGEST n = 0;
928 register LONGEST prevn = 0;
931 register int base = input_radix;
935 struct type *signed_type;
936 struct type *unsigned_type;
940 /* It's a float since it contains a point or an exponent. */
941 putithere->dval = atof (p);
945 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
979 if (c >= 'A' && c <= 'Z')
981 if (c != 'l' && c != 'u')
983 if (c >= '0' && c <= '9')
987 if (base > 10 && c >= 'a' && c <= 'f')
988 n += i = c - 'a' + 10;
989 else if (len == 0 && c == 'l')
991 else if (len == 0 && c == 'u')
994 return ERROR; /* Char not a digit */
997 return ERROR; /* Invalid digit in this base */
999 /* Portably test for overflow (only works for nonzero values, so make
1000 a second check for zero). */
1001 if((prevn >= n) && n != 0)
1002 unsigned_p=1; /* Try something unsigned */
1003 /* If range checking enabled, portably test for unsigned overflow. */
1004 if(RANGE_CHECK && n!=0)
1006 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1007 range_error("Overflow on numeric constant.");
1012 /* If the number is too big to be an int, or it's got an l suffix
1013 then it's a long. Work out if this has to be a long by
1014 shifting right and and seeing if anything remains, and the
1015 target int size is different to the target long size. */
1017 if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1019 high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1020 unsigned_type = builtin_type_unsigned_long;
1021 signed_type = builtin_type_long;
1025 high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1026 unsigned_type = builtin_type_unsigned_int;
1027 signed_type = builtin_type_int;
1030 putithere->typed_val.val = n;
1032 /* If the high bit of the worked out type is set then this number
1033 has to be unsigned. */
1035 if (unsigned_p || (n & high_bit))
1037 putithere->typed_val.type = unsigned_type;
1041 putithere->typed_val.type = signed_type;
1051 enum exp_opcode opcode;
1054 static const struct token tokentab3[] =
1056 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1057 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1060 static const struct token tokentab2[] =
1062 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1063 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1064 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1065 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1066 {"%=", ASSIGN_MODIFY, BINOP_REM},
1067 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1068 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1069 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1070 {"++", INCREMENT, BINOP_END},
1071 {"--", DECREMENT, BINOP_END},
1072 {"->", ARROW, BINOP_END},
1073 {"&&", ANDAND, BINOP_END},
1074 {"||", OROR, BINOP_END},
1075 {"::", COLONCOLON, BINOP_END},
1076 {"<<", LSH, BINOP_END},
1077 {">>", RSH, BINOP_END},
1078 {"==", EQUAL, BINOP_END},
1079 {"!=", NOTEQUAL, BINOP_END},
1080 {"<=", LEQ, BINOP_END},
1081 {">=", GEQ, BINOP_END}
1084 /* Read one token, getting characters through lexptr. */
1095 static char *tempbuf;
1096 static int tempbufsize;
1101 /* See if it is a special token of length 3. */
1102 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1103 if (STREQN (tokstart, tokentab3[i].operator, 3))
1106 yylval.opcode = tokentab3[i].opcode;
1107 return tokentab3[i].token;
1110 /* See if it is a special token of length 2. */
1111 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1112 if (STREQN (tokstart, tokentab2[i].operator, 2))
1115 yylval.opcode = tokentab2[i].opcode;
1116 return tokentab2[i].token;
1119 switch (c = *tokstart)
1131 /* We either have a character constant ('0' or '\177' for example)
1132 or we have a quoted symbol reference ('foo(int,int)' in C++
1137 c = parse_escape (&lexptr);
1139 yylval.typed_val.val = c;
1140 yylval.typed_val.type = builtin_type_char;
1145 namelen = skip_quoted (tokstart) - tokstart;
1148 lexptr = tokstart + namelen;
1153 error ("Invalid character constant.");
1163 if (paren_depth == 0)
1170 if (comma_terminates && paren_depth == 0)
1176 /* Might be a floating point number. */
1177 if (lexptr[1] < '0' || lexptr[1] > '9')
1178 goto symbol; /* Nope, must be a symbol. */
1179 /* FALL THRU into number case. */
1192 /* It's a number. */
1193 int got_dot = 0, got_e = 0, toktype;
1194 register char *p = tokstart;
1195 int hex = input_radix > 10;
1197 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1202 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1210 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1211 got_dot = got_e = 1;
1212 else if (!hex && !got_dot && *p == '.')
1214 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1215 && (*p == '-' || *p == '+'))
1216 /* This is the sign of the exponent, not the end of the
1219 /* We will take any letters or digits. parse_number will
1220 complain if past the radix, or if L or U are not final. */
1221 else if ((*p < '0' || *p > '9')
1222 && ((*p < 'a' || *p > 'z')
1223 && (*p < 'A' || *p > 'Z')))
1226 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1227 if (toktype == ERROR)
1229 char *err_copy = (char *) alloca (p - tokstart + 1);
1231 memcpy (err_copy, tokstart, p - tokstart);
1232 err_copy[p - tokstart] = 0;
1233 error ("Invalid number \"%s\".", err_copy);
1265 /* Build the gdb internal form of the input string in tempbuf,
1266 translating any standard C escape forms seen. Note that the
1267 buffer is null byte terminated *only* for the convenience of
1268 debugging gdb itself and printing the buffer contents when
1269 the buffer contains no embedded nulls. Gdb does not depend
1270 upon the buffer being null byte terminated, it uses the length
1271 string instead. This allows gdb to handle C strings (as well
1272 as strings in other languages) with embedded null bytes */
1274 tokptr = ++tokstart;
1278 /* Grow the static temp buffer if necessary, including allocating
1279 the first one on demand. */
1280 if (tempbufindex + 1 >= tempbufsize)
1282 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1288 /* Do nothing, loop will terminate. */
1292 c = parse_escape (&tokptr);
1297 tempbuf[tempbufindex++] = c;
1300 tempbuf[tempbufindex++] = *tokptr++;
1303 } while ((*tokptr != '"') && (*tokptr != '\0'));
1304 if (*tokptr++ != '"')
1306 error ("Unterminated string in expression.");
1308 tempbuf[tempbufindex] = '\0'; /* See note above */
1309 yylval.sval.ptr = tempbuf;
1310 yylval.sval.length = tempbufindex;
1315 if (!(c == '_' || c == '$'
1316 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1317 /* We must have come across a bad character (e.g. ';'). */
1318 error ("Invalid character '%c' in expression.", c);
1320 /* It's a name. See how long it is. */
1322 for (c = tokstart[namelen];
1323 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1324 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1325 c = tokstart[++namelen])
1328 /* The token "if" terminates the expression and is NOT
1329 removed from the input stream. */
1330 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1337 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1338 and $$digits (equivalent to $<-digits> if you could type that).
1339 Make token type LAST, and put the number (the digits) in yylval. */
1342 if (*tokstart == '$')
1344 register int negate = 0;
1346 /* Double dollar means negate the number and add -1 as well.
1347 Thus $$ alone means -1. */
1348 if (namelen >= 2 && tokstart[1] == '$')
1355 /* Just dollars (one or two) */
1356 yylval.lval = - negate;
1359 /* Is the rest of the token digits? */
1360 for (; c < namelen; c++)
1361 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1365 yylval.lval = atoi (tokstart + 1 + negate);
1367 yylval.lval = - yylval.lval;
1372 /* Handle tokens that refer to machine registers:
1373 $ followed by a register name. */
1375 if (*tokstart == '$') {
1376 for (c = 0; c < NUM_REGS; c++)
1377 if (namelen - 1 == strlen (reg_names[c])
1378 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1383 for (c = 0; c < num_std_regs; c++)
1384 if (namelen - 1 == strlen (std_regs[c].name)
1385 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1387 yylval.lval = std_regs[c].regnum;
1391 /* Catch specific keywords. Should be done with a data structure. */
1395 if (STREQN (tokstart, "unsigned", 8))
1397 if (current_language->la_language == language_cplus
1398 && STREQN (tokstart, "template", 8))
1400 if (STREQN (tokstart, "volatile", 8))
1401 return VOLATILE_KEYWORD;
1404 if (STREQN (tokstart, "struct", 6))
1406 if (STREQN (tokstart, "signed", 6))
1407 return SIGNED_KEYWORD;
1408 if (STREQN (tokstart, "sizeof", 6))
1412 if (current_language->la_language == language_cplus
1413 && STREQN (tokstart, "class", 5))
1415 if (STREQN (tokstart, "union", 5))
1417 if (STREQN (tokstart, "short", 5))
1419 if (STREQN (tokstart, "const", 5))
1420 return CONST_KEYWORD;
1423 if (STREQN (tokstart, "enum", 4))
1425 if (STREQN (tokstart, "long", 4))
1427 if (current_language->la_language == language_cplus
1428 && STREQN (tokstart, "this", 4))
1430 static const char this_name[] =
1431 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1433 if (lookup_symbol (this_name, expression_context_block,
1434 VAR_NAMESPACE, 0, NULL))
1439 if (STREQN (tokstart, "int", 3))
1446 yylval.sval.ptr = tokstart;
1447 yylval.sval.length = namelen;
1449 /* Any other names starting in $ are debugger internal variables. */
1451 if (*tokstart == '$')
1453 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1457 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1458 functions or symtabs. If this is not so, then ...
1459 Use token-type TYPENAME for symbols that happen to be defined
1460 currently as names of types; NAME for other symbols.
1461 The caller is not constrained to care about the distinction. */
1463 char *tmp = copy_name (yylval.sval);
1465 int is_a_field_of_this = 0;
1468 sym = lookup_symbol (tmp, expression_context_block,
1470 current_language->la_language == language_cplus
1471 ? &is_a_field_of_this : NULL,
1473 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1474 lookup_partial_symtab (tmp))
1476 yylval.ssym.sym = sym;
1477 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1480 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1482 yylval.tsym.type = SYMBOL_TYPE (sym);
1485 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1488 /* Input names that aren't symbols but ARE valid hex numbers,
1489 when the input radix permits them, can be names or numbers
1490 depending on the parse. Note we support radixes > 16 here. */
1492 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1493 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1495 YYSTYPE newlval; /* Its value is ignored. */
1496 hextype = parse_number (tokstart, namelen, 0, &newlval);
1499 yylval.ssym.sym = sym;
1500 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1505 /* Any other kind of symbol */
1506 yylval.ssym.sym = sym;
1507 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1516 error (msg ? msg : "Invalid syntax in expression.");