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
132 %type <tval> type typebase
133 %type <tvec> nonempty_typelist
134 /* %type <bval> block */
136 /* Fancy type parsing. */
137 %type <voidval> func_mod direct_abs_decl abs_decl
139 %type <lval> array_mod
141 %token <typed_val> INT
144 /* Both NAME and TYPENAME tokens represent symbols in the input,
145 and both convey their data as strings.
146 But a TYPENAME is a string that happens to be defined as a typedef
147 or builtin type name (such as int or char)
148 and a NAME is any other symbol.
149 Contexts where this distinction is not important can use the
150 nonterminal "name", which matches either NAME or TYPENAME. */
153 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
154 %token <tsym> TYPENAME
156 %type <ssym> name_not_typename
157 %type <tsym> typename
159 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
160 but which would parse as a valid number in the current input radix.
161 E.g. "c" when input_radix==16. Depending on the parse, it will be
162 turned into a name or into a number. */
164 %token <ssym> NAME_OR_INT
166 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
170 /* Special type cases, put in to allow the parser to distinguish different
172 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
173 %token <lval> LAST REGNAME
175 %token <ivar> VARIABLE
177 %token <opcode> ASSIGN_MODIFY
184 %right '=' ASSIGN_MODIFY
192 %left '<' '>' LEQ GEQ
197 %right UNARY INCREMENT DECREMENT
198 %right ARROW '.' '[' '('
199 %token <ssym> BLOCKNAME
211 { write_exp_elt_opcode(OP_TYPE);
212 write_exp_elt_type($1);
213 write_exp_elt_opcode(OP_TYPE);}
216 /* Expressions, including the comma operator. */
219 { write_exp_elt_opcode (BINOP_COMMA); }
222 /* Expressions, not including the comma operator. */
223 exp : '*' exp %prec UNARY
224 { write_exp_elt_opcode (UNOP_IND); }
226 exp : '&' exp %prec UNARY
227 { write_exp_elt_opcode (UNOP_ADDR); }
229 exp : '-' exp %prec UNARY
230 { write_exp_elt_opcode (UNOP_NEG); }
233 exp : '!' exp %prec UNARY
234 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
237 exp : '~' exp %prec UNARY
238 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
241 exp : INCREMENT exp %prec UNARY
242 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
245 exp : DECREMENT exp %prec UNARY
246 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
249 exp : exp INCREMENT %prec UNARY
250 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
253 exp : exp DECREMENT %prec UNARY
254 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
257 exp : SIZEOF exp %prec UNARY
258 { write_exp_elt_opcode (UNOP_SIZEOF); }
262 { write_exp_elt_opcode (STRUCTOP_PTR);
263 write_exp_string ($3);
264 write_exp_elt_opcode (STRUCTOP_PTR); }
267 exp : exp ARROW qualified_name
268 { /* exp->type::name becomes exp->*(&type::name) */
269 /* Note: this doesn't work if name is a
270 static member! FIXME */
271 write_exp_elt_opcode (UNOP_ADDR);
272 write_exp_elt_opcode (STRUCTOP_MPTR); }
274 exp : exp ARROW '*' exp
275 { write_exp_elt_opcode (STRUCTOP_MPTR); }
279 { write_exp_elt_opcode (STRUCTOP_STRUCT);
280 write_exp_string ($3);
281 write_exp_elt_opcode (STRUCTOP_STRUCT); }
284 exp : exp '.' qualified_name
285 { /* exp.type::name becomes exp.*(&type::name) */
286 /* Note: this doesn't work if name is a
287 static member! FIXME */
288 write_exp_elt_opcode (UNOP_ADDR);
289 write_exp_elt_opcode (STRUCTOP_MEMBER); }
292 exp : exp '.' '*' exp
293 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
296 exp : exp '[' exp1 ']'
297 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
301 /* This is to save the value of arglist_len
302 being accumulated by an outer function call. */
303 { start_arglist (); }
304 arglist ')' %prec ARROW
305 { write_exp_elt_opcode (OP_FUNCALL);
306 write_exp_elt_longcst ((LONGEST) end_arglist ());
307 write_exp_elt_opcode (OP_FUNCALL); }
317 arglist : arglist ',' exp %prec ABOVE_COMMA
322 /* This is to save the value of arglist_len
323 being accumulated by an outer function call. */
324 { start_arglist (); }
325 arglist '}' %prec ARROW
326 { write_exp_elt_opcode (OP_ARRAY);
327 write_exp_elt_longcst ((LONGEST) 0);
328 write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
329 write_exp_elt_opcode (OP_ARRAY); }
332 exp : '{' type '}' exp %prec UNARY
333 { write_exp_elt_opcode (UNOP_MEMVAL);
334 write_exp_elt_type ($2);
335 write_exp_elt_opcode (UNOP_MEMVAL); }
338 exp : '(' type ')' exp %prec UNARY
339 { write_exp_elt_opcode (UNOP_CAST);
340 write_exp_elt_type ($2);
341 write_exp_elt_opcode (UNOP_CAST); }
348 /* Binary operators in order of decreasing precedence. */
351 { write_exp_elt_opcode (BINOP_REPEAT); }
355 { write_exp_elt_opcode (BINOP_MUL); }
359 { write_exp_elt_opcode (BINOP_DIV); }
363 { write_exp_elt_opcode (BINOP_REM); }
367 { write_exp_elt_opcode (BINOP_ADD); }
371 { write_exp_elt_opcode (BINOP_SUB); }
375 { write_exp_elt_opcode (BINOP_LSH); }
379 { write_exp_elt_opcode (BINOP_RSH); }
383 { write_exp_elt_opcode (BINOP_EQUAL); }
386 exp : exp NOTEQUAL exp
387 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
391 { write_exp_elt_opcode (BINOP_LEQ); }
395 { write_exp_elt_opcode (BINOP_GEQ); }
399 { write_exp_elt_opcode (BINOP_LESS); }
403 { write_exp_elt_opcode (BINOP_GTR); }
407 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
411 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
415 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
419 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
423 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
426 exp : exp '?' exp ':' exp %prec '?'
427 { write_exp_elt_opcode (TERNOP_COND); }
431 { write_exp_elt_opcode (BINOP_ASSIGN); }
434 exp : exp ASSIGN_MODIFY exp
435 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
436 write_exp_elt_opcode ($2);
437 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
441 { write_exp_elt_opcode (OP_LONG);
442 write_exp_elt_type ($1.type);
443 write_exp_elt_longcst ((LONGEST)($1.val));
444 write_exp_elt_opcode (OP_LONG); }
449 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
450 write_exp_elt_opcode (OP_LONG);
451 write_exp_elt_type (val.typed_val.type);
452 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
453 write_exp_elt_opcode (OP_LONG);
459 { write_exp_elt_opcode (OP_DOUBLE);
460 write_exp_elt_type (builtin_type_double);
461 write_exp_elt_dblcst ($1);
462 write_exp_elt_opcode (OP_DOUBLE); }
469 { write_exp_elt_opcode (OP_LAST);
470 write_exp_elt_longcst ((LONGEST) $1);
471 write_exp_elt_opcode (OP_LAST); }
475 { write_exp_elt_opcode (OP_REGISTER);
476 write_exp_elt_longcst ((LONGEST) $1);
477 write_exp_elt_opcode (OP_REGISTER); }
481 { write_exp_elt_opcode (OP_INTERNALVAR);
482 write_exp_elt_intern ($1);
483 write_exp_elt_opcode (OP_INTERNALVAR); }
486 exp : SIZEOF '(' type ')' %prec UNARY
487 { write_exp_elt_opcode (OP_LONG);
488 write_exp_elt_type (builtin_type_int);
489 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
490 write_exp_elt_opcode (OP_LONG); }
494 { /* C strings are converted into array constants with
495 an explicit null byte added at the end. Thus
496 the array upper bound is the string length.
497 There is no such thing in C as a completely empty
499 char *sp = $1.ptr; int count = $1.length;
502 write_exp_elt_opcode (OP_LONG);
503 write_exp_elt_type (builtin_type_char);
504 write_exp_elt_longcst ((LONGEST)(*sp++));
505 write_exp_elt_opcode (OP_LONG);
507 write_exp_elt_opcode (OP_LONG);
508 write_exp_elt_type (builtin_type_char);
509 write_exp_elt_longcst ((LONGEST)'\0');
510 write_exp_elt_opcode (OP_LONG);
511 write_exp_elt_opcode (OP_ARRAY);
512 write_exp_elt_longcst ((LONGEST) 0);
513 write_exp_elt_longcst ((LONGEST) ($1.length));
514 write_exp_elt_opcode (OP_ARRAY); }
519 { write_exp_elt_opcode (OP_THIS);
520 write_exp_elt_opcode (OP_THIS); }
528 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
532 lookup_symtab (copy_name ($1.stoken));
534 $$ = BLOCKVECTOR_BLOCK
535 (BLOCKVECTOR (tem), STATIC_BLOCK);
537 error ("No file or function \"%s\".",
538 copy_name ($1.stoken));
543 block : block COLONCOLON name
545 = lookup_symbol (copy_name ($3), $1,
546 VAR_NAMESPACE, 0, NULL);
547 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
548 error ("No function \"%s\" in specified context.",
550 $$ = SYMBOL_BLOCK_VALUE (tem); }
553 variable: block COLONCOLON name
554 { struct symbol *sym;
555 sym = lookup_symbol (copy_name ($3), $1,
556 VAR_NAMESPACE, 0, NULL);
558 error ("No symbol \"%s\" in specified context.",
561 write_exp_elt_opcode (OP_VAR_VALUE);
562 write_exp_elt_sym (sym);
563 write_exp_elt_opcode (OP_VAR_VALUE); }
566 qualified_name: typebase COLONCOLON name
568 struct type *type = $1;
569 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
570 && TYPE_CODE (type) != TYPE_CODE_UNION)
571 error ("`%s' is not defined as an aggregate type.",
574 write_exp_elt_opcode (OP_SCOPE);
575 write_exp_elt_type (type);
576 write_exp_string ($3);
577 write_exp_elt_opcode (OP_SCOPE);
579 | typebase COLONCOLON '~' name
581 struct type *type = $1;
582 struct stoken tmp_token;
583 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
584 && TYPE_CODE (type) != TYPE_CODE_UNION)
585 error ("`%s' is not defined as an aggregate type.",
588 if (!STREQ (type_name_no_tag (type), $4.ptr))
589 error ("invalid destructor `%s::~%s'",
590 type_name_no_tag (type), $4.ptr);
592 tmp_token.ptr = (char*) alloca ($4.length + 2);
593 tmp_token.length = $4.length + 1;
594 tmp_token.ptr[0] = '~';
595 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
596 tmp_token.ptr[tmp_token.length] = 0;
597 write_exp_elt_opcode (OP_SCOPE);
598 write_exp_elt_type (type);
599 write_exp_string (tmp_token);
600 write_exp_elt_opcode (OP_SCOPE);
604 variable: qualified_name
607 char *name = copy_name ($2);
609 struct minimal_symbol *msymbol;
612 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
615 write_exp_elt_opcode (OP_VAR_VALUE);
616 write_exp_elt_sym (sym);
617 write_exp_elt_opcode (OP_VAR_VALUE);
621 msymbol = lookup_minimal_symbol (name,
622 (struct objfile *) NULL);
625 write_exp_elt_opcode (OP_LONG);
626 write_exp_elt_type (builtin_type_int);
627 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
628 write_exp_elt_opcode (OP_LONG);
629 write_exp_elt_opcode (UNOP_MEMVAL);
630 if (msymbol -> type == mst_data ||
631 msymbol -> type == mst_bss)
632 write_exp_elt_type (builtin_type_int);
633 else if (msymbol -> type == mst_text)
634 write_exp_elt_type (lookup_function_type (builtin_type_int));
636 write_exp_elt_type (builtin_type_char);
637 write_exp_elt_opcode (UNOP_MEMVAL);
640 if (!have_full_symbols () && !have_partial_symbols ())
641 error ("No symbol table is loaded. Use the \"file\" command.");
643 error ("No symbol \"%s\" in current context.", name);
647 variable: name_not_typename
648 { struct symbol *sym = $1.sym;
652 switch (SYMBOL_CLASS (sym))
660 if (innermost_block == 0 ||
661 contained_in (block_found,
663 innermost_block = block_found;
670 case LOC_CONST_BYTES:
672 /* In this case the expression can
673 be evaluated regardless of what
674 frame we are in, so there is no
675 need to check for the
676 innermost_block. These cases are
677 listed so that gcc -Wall will
678 report types that may not have
683 write_exp_elt_opcode (OP_VAR_VALUE);
684 write_exp_elt_sym (sym);
685 write_exp_elt_opcode (OP_VAR_VALUE);
687 else if ($1.is_a_field_of_this)
689 /* C++: it hangs off of `this'. Must
690 not inadvertently convert from a method call
692 if (innermost_block == 0 ||
693 contained_in (block_found, innermost_block))
694 innermost_block = block_found;
695 write_exp_elt_opcode (OP_THIS);
696 write_exp_elt_opcode (OP_THIS);
697 write_exp_elt_opcode (STRUCTOP_PTR);
698 write_exp_string ($1.stoken);
699 write_exp_elt_opcode (STRUCTOP_PTR);
703 struct minimal_symbol *msymbol;
704 register char *arg = copy_name ($1.stoken);
706 msymbol = lookup_minimal_symbol (arg,
707 (struct objfile *) NULL);
710 write_exp_elt_opcode (OP_LONG);
711 write_exp_elt_type (builtin_type_int);
712 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
713 write_exp_elt_opcode (OP_LONG);
714 write_exp_elt_opcode (UNOP_MEMVAL);
715 if (msymbol -> type == mst_data ||
716 msymbol -> type == mst_bss)
717 write_exp_elt_type (builtin_type_int);
718 else if (msymbol -> type == mst_text)
719 write_exp_elt_type (lookup_function_type (builtin_type_int));
721 write_exp_elt_type (builtin_type_char);
722 write_exp_elt_opcode (UNOP_MEMVAL);
724 else if (!have_full_symbols () && !have_partial_symbols ())
725 error ("No symbol table is loaded. Use the \"file\" command.");
727 error ("No symbol \"%s\" in current context.",
728 copy_name ($1.stoken));
737 /* This is where the interesting stuff happens. */
740 struct type *follow_type = $1;
741 struct type *range_type;
750 follow_type = lookup_pointer_type (follow_type);
753 follow_type = lookup_reference_type (follow_type);
756 array_size = pop_type_int ();
757 if (array_size != -1)
760 create_range_type ((struct type *) NULL,
764 create_array_type ((struct type *) NULL,
765 follow_type, range_type);
768 follow_type = lookup_pointer_type (follow_type);
771 follow_type = lookup_function_type (follow_type);
779 { push_type (tp_pointer); $$ = 0; }
781 { push_type (tp_pointer); $$ = $2; }
783 { push_type (tp_reference); $$ = 0; }
785 { push_type (tp_reference); $$ = $2; }
789 direct_abs_decl: '(' abs_decl ')'
791 | direct_abs_decl array_mod
794 push_type (tp_array);
799 push_type (tp_array);
802 | direct_abs_decl func_mod
803 { push_type (tp_function); }
805 { push_type (tp_function); }
816 | '(' nonempty_typelist ')'
817 { free ((PTR)$2); $$ = 0; }
821 | typebase COLONCOLON '*'
822 { $$ = lookup_member_type (builtin_type_int, $1); }
823 | type '(' typebase COLONCOLON '*' ')'
824 { $$ = lookup_member_type ($1, $3); }
825 | type '(' typebase COLONCOLON '*' ')' '(' ')'
826 { $$ = lookup_member_type
827 (lookup_function_type ($1), $3); }
828 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
829 { $$ = lookup_member_type
830 (lookup_function_type ($1), $3);
834 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
838 { $$ = builtin_type_int; }
840 { $$ = builtin_type_long; }
842 { $$ = builtin_type_short; }
844 { $$ = builtin_type_long; }
845 | UNSIGNED LONG INT_KEYWORD
846 { $$ = builtin_type_unsigned_long; }
848 { $$ = builtin_type_long_long; }
849 | LONG LONG INT_KEYWORD
850 { $$ = builtin_type_long_long; }
852 { $$ = builtin_type_unsigned_long_long; }
853 | UNSIGNED LONG LONG INT_KEYWORD
854 { $$ = builtin_type_unsigned_long_long; }
856 { $$ = builtin_type_short; }
857 | UNSIGNED SHORT INT_KEYWORD
858 { $$ = builtin_type_unsigned_short; }
860 { $$ = lookup_struct (copy_name ($2),
861 expression_context_block); }
863 { $$ = lookup_struct (copy_name ($2),
864 expression_context_block); }
866 { $$ = lookup_union (copy_name ($2),
867 expression_context_block); }
869 { $$ = lookup_enum (copy_name ($2),
870 expression_context_block); }
872 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
874 { $$ = builtin_type_unsigned_int; }
875 | SIGNED_KEYWORD typename
876 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
878 { $$ = builtin_type_int; }
879 | TEMPLATE name '<' type '>'
880 { $$ = lookup_template_type(copy_name($2), $4,
881 expression_context_block);
883 /* "const" and "volatile" are curently ignored. */
884 | CONST_KEYWORD typebase { $$ = $2; }
885 | VOLATILE_KEYWORD typebase { $$ = $2; }
891 $$.stoken.ptr = "int";
892 $$.stoken.length = 3;
893 $$.type = builtin_type_int;
897 $$.stoken.ptr = "long";
898 $$.stoken.length = 4;
899 $$.type = builtin_type_long;
903 $$.stoken.ptr = "short";
904 $$.stoken.length = 5;
905 $$.type = builtin_type_short;
911 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
912 $<ivec>$[0] = 1; /* Number of types in vector */
915 | nonempty_typelist ',' type
916 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
917 $$ = (struct type **) realloc ((char *) $1, len);
918 $$[$<ivec>$[0]] = $3;
922 name : NAME { $$ = $1.stoken; }
923 | BLOCKNAME { $$ = $1.stoken; }
924 | TYPENAME { $$ = $1.stoken; }
925 | NAME_OR_INT { $$ = $1.stoken; }
928 name_not_typename : NAME
930 /* These would be useful if name_not_typename was useful, but it is just
931 a fake for "variable", so these cause reduce/reduce conflicts because
932 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
933 =exp) or just an exp. If name_not_typename was ever used in an lvalue
934 context where only a name could occur, this might be useful.
941 /* Take care of parsing a number (anything that starts with a digit).
942 Set yylval and return the token type; update lexptr.
943 LEN is the number of characters in it. */
945 /*** Needs some error checking for the float case ***/
948 parse_number (p, len, parsed_float, putithere)
954 register LONGEST n = 0;
955 register LONGEST prevn = 0;
958 register int base = input_radix;
962 struct type *signed_type;
963 struct type *unsigned_type;
967 /* It's a float since it contains a point or an exponent. */
968 putithere->dval = atof (p);
972 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1006 if (c >= 'A' && c <= 'Z')
1008 if (c != 'l' && c != 'u')
1010 if (c >= '0' && c <= '9')
1014 if (base > 10 && c >= 'a' && c <= 'f')
1015 n += i = c - 'a' + 10;
1016 else if (len == 0 && c == 'l')
1018 else if (len == 0 && c == 'u')
1021 return ERROR; /* Char not a digit */
1024 return ERROR; /* Invalid digit in this base */
1026 /* Portably test for overflow (only works for nonzero values, so make
1027 a second check for zero). */
1028 if((prevn >= n) && n != 0)
1029 unsigned_p=1; /* Try something unsigned */
1030 /* If range checking enabled, portably test for unsigned overflow. */
1031 if(RANGE_CHECK && n!=0)
1033 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1034 range_error("Overflow on numeric constant.");
1039 /* If the number is too big to be an int, or it's got an l suffix
1040 then it's a long. Work out if this has to be a long by
1041 shifting right and and seeing if anything remains, and the
1042 target int size is different to the target long size. */
1044 if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1046 high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1047 unsigned_type = builtin_type_unsigned_long;
1048 signed_type = builtin_type_long;
1052 high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1053 unsigned_type = builtin_type_unsigned_int;
1054 signed_type = builtin_type_int;
1057 putithere->typed_val.val = n;
1059 /* If the high bit of the worked out type is set then this number
1060 has to be unsigned. */
1062 if (unsigned_p || (n & high_bit))
1064 putithere->typed_val.type = unsigned_type;
1068 putithere->typed_val.type = signed_type;
1078 enum exp_opcode opcode;
1081 static const struct token tokentab3[] =
1083 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1084 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1087 static const struct token tokentab2[] =
1089 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1090 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1091 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1092 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1093 {"%=", ASSIGN_MODIFY, BINOP_REM},
1094 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1095 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1096 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1097 {"++", INCREMENT, BINOP_END},
1098 {"--", DECREMENT, BINOP_END},
1099 {"->", ARROW, BINOP_END},
1100 {"&&", ANDAND, BINOP_END},
1101 {"||", OROR, BINOP_END},
1102 {"::", COLONCOLON, BINOP_END},
1103 {"<<", LSH, BINOP_END},
1104 {">>", RSH, BINOP_END},
1105 {"==", EQUAL, BINOP_END},
1106 {"!=", NOTEQUAL, BINOP_END},
1107 {"<=", LEQ, BINOP_END},
1108 {">=", GEQ, BINOP_END}
1111 /* Read one token, getting characters through lexptr. */
1122 static char *tempbuf;
1123 static int tempbufsize;
1128 /* See if it is a special token of length 3. */
1129 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1130 if (STREQN (tokstart, tokentab3[i].operator, 3))
1133 yylval.opcode = tokentab3[i].opcode;
1134 return tokentab3[i].token;
1137 /* See if it is a special token of length 2. */
1138 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1139 if (STREQN (tokstart, tokentab2[i].operator, 2))
1142 yylval.opcode = tokentab2[i].opcode;
1143 return tokentab2[i].token;
1146 switch (c = *tokstart)
1158 /* We either have a character constant ('0' or '\177' for example)
1159 or we have a quoted symbol reference ('foo(int,int)' in C++
1164 c = parse_escape (&lexptr);
1166 yylval.typed_val.val = c;
1167 yylval.typed_val.type = builtin_type_char;
1172 namelen = skip_quoted (tokstart) - tokstart;
1175 lexptr = tokstart + namelen;
1180 error ("Invalid character constant.");
1190 if (paren_depth == 0)
1197 if (comma_terminates && paren_depth == 0)
1203 /* Might be a floating point number. */
1204 if (lexptr[1] < '0' || lexptr[1] > '9')
1205 goto symbol; /* Nope, must be a symbol. */
1206 /* FALL THRU into number case. */
1219 /* It's a number. */
1220 int got_dot = 0, got_e = 0, toktype;
1221 register char *p = tokstart;
1222 int hex = input_radix > 10;
1224 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1229 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1237 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1238 got_dot = got_e = 1;
1239 else if (!hex && !got_dot && *p == '.')
1241 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1242 && (*p == '-' || *p == '+'))
1243 /* This is the sign of the exponent, not the end of the
1246 /* We will take any letters or digits. parse_number will
1247 complain if past the radix, or if L or U are not final. */
1248 else if ((*p < '0' || *p > '9')
1249 && ((*p < 'a' || *p > 'z')
1250 && (*p < 'A' || *p > 'Z')))
1253 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1254 if (toktype == ERROR)
1256 char *err_copy = (char *) alloca (p - tokstart + 1);
1258 memcpy (err_copy, tokstart, p - tokstart);
1259 err_copy[p - tokstart] = 0;
1260 error ("Invalid number \"%s\".", err_copy);
1292 /* Build the gdb internal form of the input string in tempbuf,
1293 translating any standard C escape forms seen. Note that the
1294 buffer is null byte terminated *only* for the convenience of
1295 debugging gdb itself and printing the buffer contents when
1296 the buffer contains no embedded nulls. Gdb does not depend
1297 upon the buffer being null byte terminated, it uses the length
1298 string instead. This allows gdb to handle C strings (as well
1299 as strings in other languages) with embedded null bytes */
1301 tokptr = ++tokstart;
1305 /* Grow the static temp buffer if necessary, including allocating
1306 the first one on demand. */
1307 if (tempbufindex + 1 >= tempbufsize)
1309 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1315 /* Do nothing, loop will terminate. */
1319 c = parse_escape (&tokptr);
1324 tempbuf[tempbufindex++] = c;
1327 tempbuf[tempbufindex++] = *tokptr++;
1330 } while ((*tokptr != '"') && (*tokptr != '\0'));
1331 if (*tokptr++ != '"')
1333 error ("Unterminated string in expression.");
1335 tempbuf[tempbufindex] = '\0'; /* See note above */
1336 yylval.sval.ptr = tempbuf;
1337 yylval.sval.length = tempbufindex;
1342 if (!(c == '_' || c == '$'
1343 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1344 /* We must have come across a bad character (e.g. ';'). */
1345 error ("Invalid character '%c' in expression.", c);
1347 /* It's a name. See how long it is. */
1349 for (c = tokstart[namelen];
1350 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1351 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1352 c = tokstart[++namelen])
1355 /* The token "if" terminates the expression and is NOT
1356 removed from the input stream. */
1357 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1364 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1365 and $$digits (equivalent to $<-digits> if you could type that).
1366 Make token type LAST, and put the number (the digits) in yylval. */
1369 if (*tokstart == '$')
1371 register int negate = 0;
1373 /* Double dollar means negate the number and add -1 as well.
1374 Thus $$ alone means -1. */
1375 if (namelen >= 2 && tokstart[1] == '$')
1382 /* Just dollars (one or two) */
1383 yylval.lval = - negate;
1386 /* Is the rest of the token digits? */
1387 for (; c < namelen; c++)
1388 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1392 yylval.lval = atoi (tokstart + 1 + negate);
1394 yylval.lval = - yylval.lval;
1399 /* Handle tokens that refer to machine registers:
1400 $ followed by a register name. */
1402 if (*tokstart == '$') {
1403 for (c = 0; c < NUM_REGS; c++)
1404 if (namelen - 1 == strlen (reg_names[c])
1405 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1410 for (c = 0; c < num_std_regs; c++)
1411 if (namelen - 1 == strlen (std_regs[c].name)
1412 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1414 yylval.lval = std_regs[c].regnum;
1418 /* Catch specific keywords. Should be done with a data structure. */
1422 if (STREQN (tokstart, "unsigned", 8))
1424 if (current_language->la_language == language_cplus
1425 && STREQN (tokstart, "template", 8))
1427 if (STREQN (tokstart, "volatile", 8))
1428 return VOLATILE_KEYWORD;
1431 if (STREQN (tokstart, "struct", 6))
1433 if (STREQN (tokstart, "signed", 6))
1434 return SIGNED_KEYWORD;
1435 if (STREQN (tokstart, "sizeof", 6))
1439 if (current_language->la_language == language_cplus
1440 && STREQN (tokstart, "class", 5))
1442 if (STREQN (tokstart, "union", 5))
1444 if (STREQN (tokstart, "short", 5))
1446 if (STREQN (tokstart, "const", 5))
1447 return CONST_KEYWORD;
1450 if (STREQN (tokstart, "enum", 4))
1452 if (STREQN (tokstart, "long", 4))
1454 if (current_language->la_language == language_cplus
1455 && STREQN (tokstart, "this", 4))
1457 static const char this_name[] =
1458 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1460 if (lookup_symbol (this_name, expression_context_block,
1461 VAR_NAMESPACE, 0, NULL))
1466 if (STREQN (tokstart, "int", 3))
1473 yylval.sval.ptr = tokstart;
1474 yylval.sval.length = namelen;
1476 /* Any other names starting in $ are debugger internal variables. */
1478 if (*tokstart == '$')
1480 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1484 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1485 functions or symtabs. If this is not so, then ...
1486 Use token-type TYPENAME for symbols that happen to be defined
1487 currently as names of types; NAME for other symbols.
1488 The caller is not constrained to care about the distinction. */
1490 char *tmp = copy_name (yylval.sval);
1492 int is_a_field_of_this = 0;
1495 sym = lookup_symbol (tmp, expression_context_block,
1497 current_language->la_language == language_cplus
1498 ? &is_a_field_of_this : NULL,
1500 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1501 lookup_partial_symtab (tmp))
1503 yylval.ssym.sym = sym;
1504 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1507 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1509 yylval.tsym.type = SYMBOL_TYPE (sym);
1512 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1515 /* Input names that aren't symbols but ARE valid hex numbers,
1516 when the input radix permits them, can be names or numbers
1517 depending on the parse. Note we support radixes > 16 here. */
1519 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1520 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1522 YYSTYPE newlval; /* Its value is ignored. */
1523 hextype = parse_number (tokstart, namelen, 0, &newlval);
1526 yylval.ssym.sym = sym;
1527 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1532 /* Any other kind of symbol */
1533 yylval.ssym.sym = sym;
1534 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1543 error (msg ? msg : "Invalid syntax in expression.");