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 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
47 as well as gratuitiously global symbol names, so we can have multiple
48 yacc generated parsers in gdb. Note that these are only the variables
49 produced by yacc. If other parser generators (bison, byacc, etc) produce
50 additional global names that conflict at link time, then those parser
51 generators need to be fixed instead of adding those names to this list. */
53 #define yymaxdepth c_maxdepth
54 #define yyparse c_parse
56 #define yyerror c_error
59 #define yydebug c_debug
68 #define yyerrflag c_errflag
69 #define yynerrs c_nerrs
74 #define yystate c_state
80 #define yyreds c_reds /* With YYDEBUG defined */
81 #define yytoks c_toks /* With YYDEBUG defined */
84 #define YYDEBUG 0 /* Default to no yydebug support */
88 yyparse PARAMS ((void));
91 yylex PARAMS ((void));
94 yyerror PARAMS ((char *));
98 /* Although the yacc "value" of an expression is not used,
99 since the result is stored in the structure being created,
100 other node types do have values. */
105 unsigned LONGEST ulval;
115 struct symtoken ssym;
118 enum exp_opcode opcode;
119 struct internalvar *ivar;
126 /* YYSTYPE gets defined by %union */
128 parse_number PARAMS ((char *, int, int, YYSTYPE *));
131 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
133 %type <tval> type typebase
134 %type <tvec> nonempty_typelist
135 /* %type <bval> block */
137 /* Fancy type parsing. */
138 %type <voidval> func_mod direct_abs_decl abs_decl
140 %type <lval> array_mod
142 %token <typed_val> INT
145 /* Both NAME and TYPENAME tokens represent symbols in the input,
146 and both convey their data as strings.
147 But a TYPENAME is a string that happens to be defined as a typedef
148 or builtin type name (such as int or char)
149 and a NAME is any other symbol.
150 Contexts where this distinction is not important can use the
151 nonterminal "name", which matches either NAME or TYPENAME. */
154 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
155 %token <tsym> TYPENAME
157 %type <ssym> name_not_typename
158 %type <tsym> typename
160 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
161 but which would parse as a valid number in the current input radix.
162 E.g. "c" when input_radix==16. Depending on the parse, it will be
163 turned into a name or into a number. */
165 %token <ssym> NAME_OR_INT
167 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
171 /* Special type cases, put in to allow the parser to distinguish different
173 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
174 %token <lval> LAST REGNAME
176 %token <ivar> VARIABLE
178 %token <opcode> ASSIGN_MODIFY
185 %right '=' ASSIGN_MODIFY
193 %left '<' '>' LEQ GEQ
198 %right UNARY INCREMENT DECREMENT
199 %right ARROW '.' '[' '('
200 %token <ssym> BLOCKNAME
212 { write_exp_elt_opcode(OP_TYPE);
213 write_exp_elt_type($1);
214 write_exp_elt_opcode(OP_TYPE);}
217 /* Expressions, including the comma operator. */
220 { write_exp_elt_opcode (BINOP_COMMA); }
223 /* Expressions, not including the comma operator. */
224 exp : '*' exp %prec UNARY
225 { write_exp_elt_opcode (UNOP_IND); }
227 exp : '&' exp %prec UNARY
228 { write_exp_elt_opcode (UNOP_ADDR); }
230 exp : '-' exp %prec UNARY
231 { write_exp_elt_opcode (UNOP_NEG); }
234 exp : '!' exp %prec UNARY
235 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
238 exp : '~' exp %prec UNARY
239 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
242 exp : INCREMENT exp %prec UNARY
243 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
246 exp : DECREMENT exp %prec UNARY
247 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
250 exp : exp INCREMENT %prec UNARY
251 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
254 exp : exp DECREMENT %prec UNARY
255 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
258 exp : SIZEOF exp %prec UNARY
259 { write_exp_elt_opcode (UNOP_SIZEOF); }
263 { write_exp_elt_opcode (STRUCTOP_PTR);
264 write_exp_string ($3);
265 write_exp_elt_opcode (STRUCTOP_PTR); }
268 exp : exp ARROW qualified_name
269 { /* exp->type::name becomes exp->*(&type::name) */
270 /* Note: this doesn't work if name is a
271 static member! FIXME */
272 write_exp_elt_opcode (UNOP_ADDR);
273 write_exp_elt_opcode (STRUCTOP_MPTR); }
275 exp : exp ARROW '*' exp
276 { write_exp_elt_opcode (STRUCTOP_MPTR); }
280 { write_exp_elt_opcode (STRUCTOP_STRUCT);
281 write_exp_string ($3);
282 write_exp_elt_opcode (STRUCTOP_STRUCT); }
285 exp : exp '.' qualified_name
286 { /* exp.type::name becomes exp.*(&type::name) */
287 /* Note: this doesn't work if name is a
288 static member! FIXME */
289 write_exp_elt_opcode (UNOP_ADDR);
290 write_exp_elt_opcode (STRUCTOP_MEMBER); }
293 exp : exp '.' '*' exp
294 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
297 exp : exp '[' exp1 ']'
298 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
302 /* This is to save the value of arglist_len
303 being accumulated by an outer function call. */
304 { start_arglist (); }
305 arglist ')' %prec ARROW
306 { write_exp_elt_opcode (OP_FUNCALL);
307 write_exp_elt_longcst ((LONGEST) end_arglist ());
308 write_exp_elt_opcode (OP_FUNCALL); }
312 { start_arglist (); }
322 arglist : arglist ',' exp %prec ABOVE_COMMA
327 { $$ = end_arglist () - 1; }
329 exp : lcurly arglist rcurly %prec ARROW
330 { write_exp_elt_opcode (OP_ARRAY);
331 write_exp_elt_longcst ((LONGEST) 0);
332 write_exp_elt_longcst ((LONGEST) $3);
333 write_exp_elt_opcode (OP_ARRAY); }
336 exp : lcurly type rcurly exp %prec UNARY
337 { write_exp_elt_opcode (UNOP_MEMVAL);
338 write_exp_elt_type ($2);
339 write_exp_elt_opcode (UNOP_MEMVAL); }
342 exp : '(' type ')' exp %prec UNARY
343 { write_exp_elt_opcode (UNOP_CAST);
344 write_exp_elt_type ($2);
345 write_exp_elt_opcode (UNOP_CAST); }
352 /* Binary operators in order of decreasing precedence. */
355 { write_exp_elt_opcode (BINOP_REPEAT); }
359 { write_exp_elt_opcode (BINOP_MUL); }
363 { write_exp_elt_opcode (BINOP_DIV); }
367 { write_exp_elt_opcode (BINOP_REM); }
371 { write_exp_elt_opcode (BINOP_ADD); }
375 { write_exp_elt_opcode (BINOP_SUB); }
379 { write_exp_elt_opcode (BINOP_LSH); }
383 { write_exp_elt_opcode (BINOP_RSH); }
387 { write_exp_elt_opcode (BINOP_EQUAL); }
390 exp : exp NOTEQUAL exp
391 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
395 { write_exp_elt_opcode (BINOP_LEQ); }
399 { write_exp_elt_opcode (BINOP_GEQ); }
403 { write_exp_elt_opcode (BINOP_LESS); }
407 { write_exp_elt_opcode (BINOP_GTR); }
411 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
415 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
419 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
423 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
427 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
430 exp : exp '?' exp ':' exp %prec '?'
431 { write_exp_elt_opcode (TERNOP_COND); }
435 { write_exp_elt_opcode (BINOP_ASSIGN); }
438 exp : exp ASSIGN_MODIFY exp
439 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
440 write_exp_elt_opcode ($2);
441 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
445 { write_exp_elt_opcode (OP_LONG);
446 write_exp_elt_type ($1.type);
447 write_exp_elt_longcst ((LONGEST)($1.val));
448 write_exp_elt_opcode (OP_LONG); }
453 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
454 write_exp_elt_opcode (OP_LONG);
455 write_exp_elt_type (val.typed_val.type);
456 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
457 write_exp_elt_opcode (OP_LONG);
463 { write_exp_elt_opcode (OP_DOUBLE);
464 write_exp_elt_type (builtin_type_double);
465 write_exp_elt_dblcst ($1);
466 write_exp_elt_opcode (OP_DOUBLE); }
473 { write_exp_elt_opcode (OP_LAST);
474 write_exp_elt_longcst ((LONGEST) $1);
475 write_exp_elt_opcode (OP_LAST); }
479 { write_exp_elt_opcode (OP_REGISTER);
480 write_exp_elt_longcst ((LONGEST) $1);
481 write_exp_elt_opcode (OP_REGISTER); }
485 { write_exp_elt_opcode (OP_INTERNALVAR);
486 write_exp_elt_intern ($1);
487 write_exp_elt_opcode (OP_INTERNALVAR); }
490 exp : SIZEOF '(' type ')' %prec UNARY
491 { write_exp_elt_opcode (OP_LONG);
492 write_exp_elt_type (builtin_type_int);
493 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
494 write_exp_elt_opcode (OP_LONG); }
498 { /* C strings are converted into array constants with
499 an explicit null byte added at the end. Thus
500 the array upper bound is the string length.
501 There is no such thing in C as a completely empty
503 char *sp = $1.ptr; int count = $1.length;
506 write_exp_elt_opcode (OP_LONG);
507 write_exp_elt_type (builtin_type_char);
508 write_exp_elt_longcst ((LONGEST)(*sp++));
509 write_exp_elt_opcode (OP_LONG);
511 write_exp_elt_opcode (OP_LONG);
512 write_exp_elt_type (builtin_type_char);
513 write_exp_elt_longcst ((LONGEST)'\0');
514 write_exp_elt_opcode (OP_LONG);
515 write_exp_elt_opcode (OP_ARRAY);
516 write_exp_elt_longcst ((LONGEST) 0);
517 write_exp_elt_longcst ((LONGEST) ($1.length));
518 write_exp_elt_opcode (OP_ARRAY); }
523 { write_exp_elt_opcode (OP_THIS);
524 write_exp_elt_opcode (OP_THIS); }
532 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
536 lookup_symtab (copy_name ($1.stoken));
538 $$ = BLOCKVECTOR_BLOCK
539 (BLOCKVECTOR (tem), STATIC_BLOCK);
541 error ("No file or function \"%s\".",
542 copy_name ($1.stoken));
547 block : block COLONCOLON name
549 = lookup_symbol (copy_name ($3), $1,
550 VAR_NAMESPACE, 0, NULL);
551 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
552 error ("No function \"%s\" in specified context.",
554 $$ = SYMBOL_BLOCK_VALUE (tem); }
557 variable: block COLONCOLON name
558 { struct symbol *sym;
559 sym = lookup_symbol (copy_name ($3), $1,
560 VAR_NAMESPACE, 0, NULL);
562 error ("No symbol \"%s\" in specified context.",
565 write_exp_elt_opcode (OP_VAR_VALUE);
566 write_exp_elt_sym (sym);
567 write_exp_elt_opcode (OP_VAR_VALUE); }
570 qualified_name: typebase COLONCOLON name
572 struct type *type = $1;
573 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
574 && TYPE_CODE (type) != TYPE_CODE_UNION)
575 error ("`%s' is not defined as an aggregate type.",
578 write_exp_elt_opcode (OP_SCOPE);
579 write_exp_elt_type (type);
580 write_exp_string ($3);
581 write_exp_elt_opcode (OP_SCOPE);
583 | typebase COLONCOLON '~' name
585 struct type *type = $1;
586 struct stoken tmp_token;
587 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
588 && TYPE_CODE (type) != TYPE_CODE_UNION)
589 error ("`%s' is not defined as an aggregate type.",
592 if (!STREQ (type_name_no_tag (type), $4.ptr))
593 error ("invalid destructor `%s::~%s'",
594 type_name_no_tag (type), $4.ptr);
596 tmp_token.ptr = (char*) alloca ($4.length + 2);
597 tmp_token.length = $4.length + 1;
598 tmp_token.ptr[0] = '~';
599 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
600 tmp_token.ptr[tmp_token.length] = 0;
601 write_exp_elt_opcode (OP_SCOPE);
602 write_exp_elt_type (type);
603 write_exp_string (tmp_token);
604 write_exp_elt_opcode (OP_SCOPE);
608 variable: qualified_name
611 char *name = copy_name ($2);
613 struct minimal_symbol *msymbol;
616 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
619 write_exp_elt_opcode (OP_VAR_VALUE);
620 write_exp_elt_sym (sym);
621 write_exp_elt_opcode (OP_VAR_VALUE);
625 msymbol = lookup_minimal_symbol (name,
626 (struct objfile *) NULL);
629 write_exp_elt_opcode (OP_LONG);
630 write_exp_elt_type (builtin_type_int);
631 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
632 write_exp_elt_opcode (OP_LONG);
633 write_exp_elt_opcode (UNOP_MEMVAL);
634 if (msymbol -> type == mst_data ||
635 msymbol -> type == mst_bss)
636 write_exp_elt_type (builtin_type_int);
637 else if (msymbol -> type == mst_text)
638 write_exp_elt_type (lookup_function_type (builtin_type_int));
640 write_exp_elt_type (builtin_type_char);
641 write_exp_elt_opcode (UNOP_MEMVAL);
644 if (!have_full_symbols () && !have_partial_symbols ())
645 error ("No symbol table is loaded. Use the \"file\" command.");
647 error ("No symbol \"%s\" in current context.", name);
651 variable: name_not_typename
652 { struct symbol *sym = $1.sym;
656 switch (SYMBOL_CLASS (sym))
664 if (innermost_block == 0 ||
665 contained_in (block_found,
667 innermost_block = block_found;
674 case LOC_CONST_BYTES:
676 /* In this case the expression can
677 be evaluated regardless of what
678 frame we are in, so there is no
679 need to check for the
680 innermost_block. These cases are
681 listed so that gcc -Wall will
682 report types that may not have
687 write_exp_elt_opcode (OP_VAR_VALUE);
688 write_exp_elt_sym (sym);
689 write_exp_elt_opcode (OP_VAR_VALUE);
691 else if ($1.is_a_field_of_this)
693 /* C++: it hangs off of `this'. Must
694 not inadvertently convert from a method call
696 if (innermost_block == 0 ||
697 contained_in (block_found, innermost_block))
698 innermost_block = block_found;
699 write_exp_elt_opcode (OP_THIS);
700 write_exp_elt_opcode (OP_THIS);
701 write_exp_elt_opcode (STRUCTOP_PTR);
702 write_exp_string ($1.stoken);
703 write_exp_elt_opcode (STRUCTOP_PTR);
707 struct minimal_symbol *msymbol;
708 register char *arg = copy_name ($1.stoken);
710 msymbol = lookup_minimal_symbol (arg,
711 (struct objfile *) NULL);
714 write_exp_elt_opcode (OP_LONG);
715 write_exp_elt_type (builtin_type_int);
716 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
717 write_exp_elt_opcode (OP_LONG);
718 write_exp_elt_opcode (UNOP_MEMVAL);
719 if (msymbol -> type == mst_data ||
720 msymbol -> type == mst_bss)
721 write_exp_elt_type (builtin_type_int);
722 else if (msymbol -> type == mst_text)
723 write_exp_elt_type (lookup_function_type (builtin_type_int));
725 write_exp_elt_type (builtin_type_char);
726 write_exp_elt_opcode (UNOP_MEMVAL);
728 else if (!have_full_symbols () && !have_partial_symbols ())
729 error ("No symbol table is loaded. Use the \"file\" command.");
731 error ("No symbol \"%s\" in current context.",
732 copy_name ($1.stoken));
741 /* This is where the interesting stuff happens. */
744 struct type *follow_type = $1;
745 struct type *range_type;
754 follow_type = lookup_pointer_type (follow_type);
757 follow_type = lookup_reference_type (follow_type);
760 array_size = pop_type_int ();
761 if (array_size != -1)
764 create_range_type ((struct type *) NULL,
768 create_array_type ((struct type *) NULL,
769 follow_type, range_type);
772 follow_type = lookup_pointer_type (follow_type);
775 follow_type = lookup_function_type (follow_type);
783 { push_type (tp_pointer); $$ = 0; }
785 { push_type (tp_pointer); $$ = $2; }
787 { push_type (tp_reference); $$ = 0; }
789 { push_type (tp_reference); $$ = $2; }
793 direct_abs_decl: '(' abs_decl ')'
795 | direct_abs_decl array_mod
798 push_type (tp_array);
803 push_type (tp_array);
806 | direct_abs_decl func_mod
807 { push_type (tp_function); }
809 { push_type (tp_function); }
820 | '(' nonempty_typelist ')'
821 { free ((PTR)$2); $$ = 0; }
825 | typebase COLONCOLON '*'
826 { $$ = lookup_member_type (builtin_type_int, $1); }
827 | type '(' typebase COLONCOLON '*' ')'
828 { $$ = lookup_member_type ($1, $3); }
829 | type '(' typebase COLONCOLON '*' ')' '(' ')'
830 { $$ = lookup_member_type
831 (lookup_function_type ($1), $3); }
832 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
833 { $$ = lookup_member_type
834 (lookup_function_type ($1), $3);
838 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
842 { $$ = builtin_type_int; }
844 { $$ = builtin_type_long; }
846 { $$ = builtin_type_short; }
848 { $$ = builtin_type_long; }
849 | UNSIGNED LONG INT_KEYWORD
850 { $$ = builtin_type_unsigned_long; }
852 { $$ = builtin_type_long_long; }
853 | LONG LONG INT_KEYWORD
854 { $$ = builtin_type_long_long; }
856 { $$ = builtin_type_unsigned_long_long; }
857 | UNSIGNED LONG LONG INT_KEYWORD
858 { $$ = builtin_type_unsigned_long_long; }
860 { $$ = builtin_type_short; }
861 | UNSIGNED SHORT INT_KEYWORD
862 { $$ = builtin_type_unsigned_short; }
864 { $$ = lookup_struct (copy_name ($2),
865 expression_context_block); }
867 { $$ = lookup_struct (copy_name ($2),
868 expression_context_block); }
870 { $$ = lookup_union (copy_name ($2),
871 expression_context_block); }
873 { $$ = lookup_enum (copy_name ($2),
874 expression_context_block); }
876 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
878 { $$ = builtin_type_unsigned_int; }
879 | SIGNED_KEYWORD typename
880 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
882 { $$ = builtin_type_int; }
883 | TEMPLATE name '<' type '>'
884 { $$ = lookup_template_type(copy_name($2), $4,
885 expression_context_block);
887 /* "const" and "volatile" are curently ignored. */
888 | CONST_KEYWORD typebase { $$ = $2; }
889 | VOLATILE_KEYWORD typebase { $$ = $2; }
895 $$.stoken.ptr = "int";
896 $$.stoken.length = 3;
897 $$.type = builtin_type_int;
901 $$.stoken.ptr = "long";
902 $$.stoken.length = 4;
903 $$.type = builtin_type_long;
907 $$.stoken.ptr = "short";
908 $$.stoken.length = 5;
909 $$.type = builtin_type_short;
915 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
916 $<ivec>$[0] = 1; /* Number of types in vector */
919 | nonempty_typelist ',' type
920 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
921 $$ = (struct type **) realloc ((char *) $1, len);
922 $$[$<ivec>$[0]] = $3;
926 name : NAME { $$ = $1.stoken; }
927 | BLOCKNAME { $$ = $1.stoken; }
928 | TYPENAME { $$ = $1.stoken; }
929 | NAME_OR_INT { $$ = $1.stoken; }
932 name_not_typename : NAME
934 /* These would be useful if name_not_typename was useful, but it is just
935 a fake for "variable", so these cause reduce/reduce conflicts because
936 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
937 =exp) or just an exp. If name_not_typename was ever used in an lvalue
938 context where only a name could occur, this might be useful.
945 /* Take care of parsing a number (anything that starts with a digit).
946 Set yylval and return the token type; update lexptr.
947 LEN is the number of characters in it. */
949 /*** Needs some error checking for the float case ***/
952 parse_number (p, len, parsed_float, putithere)
958 register LONGEST n = 0;
959 register LONGEST prevn = 0;
962 register int base = input_radix;
966 struct type *signed_type;
967 struct type *unsigned_type;
971 /* It's a float since it contains a point or an exponent. */
972 putithere->dval = atof (p);
976 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1010 if (c >= 'A' && c <= 'Z')
1012 if (c != 'l' && c != 'u')
1014 if (c >= '0' && c <= '9')
1018 if (base > 10 && c >= 'a' && c <= 'f')
1019 n += i = c - 'a' + 10;
1020 else if (len == 0 && c == 'l')
1022 else if (len == 0 && c == 'u')
1025 return ERROR; /* Char not a digit */
1028 return ERROR; /* Invalid digit in this base */
1030 /* Portably test for overflow (only works for nonzero values, so make
1031 a second check for zero). */
1032 if((prevn >= n) && n != 0)
1033 unsigned_p=1; /* Try something unsigned */
1034 /* If range checking enabled, portably test for unsigned overflow. */
1035 if(RANGE_CHECK && n!=0)
1037 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1038 range_error("Overflow on numeric constant.");
1043 /* If the number is too big to be an int, or it's got an l suffix
1044 then it's a long. Work out if this has to be a long by
1045 shifting right and and seeing if anything remains, and the
1046 target int size is different to the target long size. */
1048 if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1050 high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1051 unsigned_type = builtin_type_unsigned_long;
1052 signed_type = builtin_type_long;
1056 high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1057 unsigned_type = builtin_type_unsigned_int;
1058 signed_type = builtin_type_int;
1061 putithere->typed_val.val = n;
1063 /* If the high bit of the worked out type is set then this number
1064 has to be unsigned. */
1066 if (unsigned_p || (n & high_bit))
1068 putithere->typed_val.type = unsigned_type;
1072 putithere->typed_val.type = signed_type;
1082 enum exp_opcode opcode;
1085 static const struct token tokentab3[] =
1087 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1088 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1091 static const struct token tokentab2[] =
1093 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1094 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1095 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1096 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1097 {"%=", ASSIGN_MODIFY, BINOP_REM},
1098 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1099 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1100 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1101 {"++", INCREMENT, BINOP_END},
1102 {"--", DECREMENT, BINOP_END},
1103 {"->", ARROW, BINOP_END},
1104 {"&&", ANDAND, BINOP_END},
1105 {"||", OROR, BINOP_END},
1106 {"::", COLONCOLON, BINOP_END},
1107 {"<<", LSH, BINOP_END},
1108 {">>", RSH, BINOP_END},
1109 {"==", EQUAL, BINOP_END},
1110 {"!=", NOTEQUAL, BINOP_END},
1111 {"<=", LEQ, BINOP_END},
1112 {">=", GEQ, BINOP_END}
1115 /* Read one token, getting characters through lexptr. */
1126 static char *tempbuf;
1127 static int tempbufsize;
1132 /* See if it is a special token of length 3. */
1133 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1134 if (STREQN (tokstart, tokentab3[i].operator, 3))
1137 yylval.opcode = tokentab3[i].opcode;
1138 return tokentab3[i].token;
1141 /* See if it is a special token of length 2. */
1142 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1143 if (STREQN (tokstart, tokentab2[i].operator, 2))
1146 yylval.opcode = tokentab2[i].opcode;
1147 return tokentab2[i].token;
1150 switch (c = *tokstart)
1162 /* We either have a character constant ('0' or '\177' for example)
1163 or we have a quoted symbol reference ('foo(int,int)' in C++
1168 c = parse_escape (&lexptr);
1170 yylval.typed_val.val = c;
1171 yylval.typed_val.type = builtin_type_char;
1176 namelen = skip_quoted (tokstart) - tokstart;
1179 lexptr = tokstart + namelen;
1184 error ("Invalid character constant.");
1194 if (paren_depth == 0)
1201 if (comma_terminates && paren_depth == 0)
1207 /* Might be a floating point number. */
1208 if (lexptr[1] < '0' || lexptr[1] > '9')
1209 goto symbol; /* Nope, must be a symbol. */
1210 /* FALL THRU into number case. */
1223 /* It's a number. */
1224 int got_dot = 0, got_e = 0, toktype;
1225 register char *p = tokstart;
1226 int hex = input_radix > 10;
1228 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1233 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1241 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1242 got_dot = got_e = 1;
1243 else if (!hex && !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, 0, NULL))
1470 if (STREQN (tokstart, "int", 3))
1477 yylval.sval.ptr = tokstart;
1478 yylval.sval.length = namelen;
1480 /* Any other names starting in $ are debugger internal variables. */
1482 if (*tokstart == '$')
1484 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1488 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1489 functions or symtabs. If this is not so, then ...
1490 Use token-type TYPENAME for symbols that happen to be defined
1491 currently as names of types; NAME for other symbols.
1492 The caller is not constrained to care about the distinction. */
1494 char *tmp = copy_name (yylval.sval);
1496 int is_a_field_of_this = 0;
1499 sym = lookup_symbol (tmp, expression_context_block,
1501 current_language->la_language == language_cplus
1502 ? &is_a_field_of_this : NULL,
1504 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1505 lookup_partial_symtab (tmp))
1507 yylval.ssym.sym = sym;
1508 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1511 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1513 yylval.tsym.type = SYMBOL_TYPE (sym);
1516 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1519 /* Input names that aren't symbols but ARE valid hex numbers,
1520 when the input radix permits them, can be names or numbers
1521 depending on the parse. Note we support radixes > 16 here. */
1523 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1524 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1526 YYSTYPE newlval; /* Its value is ignored. */
1527 hextype = parse_number (tokstart, namelen, 0, &newlval);
1530 yylval.ssym.sym = sym;
1531 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1536 /* Any other kind of symbol */
1537 yylval.ssym.sym = sym;
1538 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1547 error (msg ? msg : "Invalid syntax in expression.");