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
321 exp : '{' type '}' exp %prec UNARY
322 { write_exp_elt_opcode (UNOP_MEMVAL);
323 write_exp_elt_type ($2);
324 write_exp_elt_opcode (UNOP_MEMVAL); }
327 exp : '(' type ')' exp %prec UNARY
328 { write_exp_elt_opcode (UNOP_CAST);
329 write_exp_elt_type ($2);
330 write_exp_elt_opcode (UNOP_CAST); }
337 /* Binary operators in order of decreasing precedence. */
340 { write_exp_elt_opcode (BINOP_REPEAT); }
344 { write_exp_elt_opcode (BINOP_MUL); }
348 { write_exp_elt_opcode (BINOP_DIV); }
352 { write_exp_elt_opcode (BINOP_REM); }
356 { write_exp_elt_opcode (BINOP_ADD); }
360 { write_exp_elt_opcode (BINOP_SUB); }
364 { write_exp_elt_opcode (BINOP_LSH); }
368 { write_exp_elt_opcode (BINOP_RSH); }
372 { write_exp_elt_opcode (BINOP_EQUAL); }
375 exp : exp NOTEQUAL exp
376 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
380 { write_exp_elt_opcode (BINOP_LEQ); }
384 { write_exp_elt_opcode (BINOP_GEQ); }
388 { write_exp_elt_opcode (BINOP_LESS); }
392 { write_exp_elt_opcode (BINOP_GTR); }
396 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
400 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
404 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
408 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
412 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
415 exp : exp '?' exp ':' exp %prec '?'
416 { write_exp_elt_opcode (TERNOP_COND); }
420 { write_exp_elt_opcode (BINOP_ASSIGN); }
423 exp : exp ASSIGN_MODIFY exp
424 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
425 write_exp_elt_opcode ($2);
426 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
430 { write_exp_elt_opcode (OP_LONG);
431 write_exp_elt_type ($1.type);
432 write_exp_elt_longcst ((LONGEST)($1.val));
433 write_exp_elt_opcode (OP_LONG); }
438 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
439 write_exp_elt_opcode (OP_LONG);
440 write_exp_elt_type (val.typed_val.type);
441 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
442 write_exp_elt_opcode (OP_LONG);
448 { write_exp_elt_opcode (OP_DOUBLE);
449 write_exp_elt_type (builtin_type_double);
450 write_exp_elt_dblcst ($1);
451 write_exp_elt_opcode (OP_DOUBLE); }
458 { write_exp_elt_opcode (OP_LAST);
459 write_exp_elt_longcst ((LONGEST) $1);
460 write_exp_elt_opcode (OP_LAST); }
464 { write_exp_elt_opcode (OP_REGISTER);
465 write_exp_elt_longcst ((LONGEST) $1);
466 write_exp_elt_opcode (OP_REGISTER); }
470 { write_exp_elt_opcode (OP_INTERNALVAR);
471 write_exp_elt_intern ($1);
472 write_exp_elt_opcode (OP_INTERNALVAR); }
475 exp : SIZEOF '(' type ')' %prec UNARY
476 { write_exp_elt_opcode (OP_LONG);
477 write_exp_elt_type (builtin_type_int);
478 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
479 write_exp_elt_opcode (OP_LONG); }
483 { /* C strings are converted into array constants with
484 an explicit null byte added at the end. Thus
485 the array upper bound is the string length.
486 There is no such thing in C as a completely empty
488 char *sp = $1.ptr; int count = $1.length;
491 write_exp_elt_opcode (OP_LONG);
492 write_exp_elt_type (builtin_type_char);
493 write_exp_elt_longcst ((LONGEST)(*sp++));
494 write_exp_elt_opcode (OP_LONG);
496 write_exp_elt_opcode (OP_LONG);
497 write_exp_elt_type (builtin_type_char);
498 write_exp_elt_longcst ((LONGEST)'\0');
499 write_exp_elt_opcode (OP_LONG);
500 write_exp_elt_opcode (OP_ARRAY);
501 write_exp_elt_longcst ((LONGEST) 0);
502 write_exp_elt_longcst ((LONGEST) ($1.length));
503 write_exp_elt_opcode (OP_ARRAY); }
508 { write_exp_elt_opcode (OP_THIS);
509 write_exp_elt_opcode (OP_THIS); }
517 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
521 lookup_symtab (copy_name ($1.stoken));
523 $$ = BLOCKVECTOR_BLOCK
524 (BLOCKVECTOR (tem), STATIC_BLOCK);
526 error ("No file or function \"%s\".",
527 copy_name ($1.stoken));
532 block : block COLONCOLON name
534 = lookup_symbol (copy_name ($3), $1,
535 VAR_NAMESPACE, 0, NULL);
536 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
537 error ("No function \"%s\" in specified context.",
539 $$ = SYMBOL_BLOCK_VALUE (tem); }
542 variable: block COLONCOLON name
543 { struct symbol *sym;
544 sym = lookup_symbol (copy_name ($3), $1,
545 VAR_NAMESPACE, 0, NULL);
547 error ("No symbol \"%s\" in specified context.",
550 write_exp_elt_opcode (OP_VAR_VALUE);
551 write_exp_elt_sym (sym);
552 write_exp_elt_opcode (OP_VAR_VALUE); }
555 qualified_name: typebase COLONCOLON name
557 struct type *type = $1;
558 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
559 && TYPE_CODE (type) != TYPE_CODE_UNION)
560 error ("`%s' is not defined as an aggregate type.",
563 write_exp_elt_opcode (OP_SCOPE);
564 write_exp_elt_type (type);
565 write_exp_string ($3);
566 write_exp_elt_opcode (OP_SCOPE);
568 | typebase COLONCOLON '~' name
570 struct type *type = $1;
571 struct stoken tmp_token;
572 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
573 && TYPE_CODE (type) != TYPE_CODE_UNION)
574 error ("`%s' is not defined as an aggregate type.",
577 if (!STREQ (type_name_no_tag (type), $4.ptr))
578 error ("invalid destructor `%s::~%s'",
579 type_name_no_tag (type), $4.ptr);
581 tmp_token.ptr = (char*) alloca ($4.length + 2);
582 tmp_token.length = $4.length + 1;
583 tmp_token.ptr[0] = '~';
584 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
585 tmp_token.ptr[tmp_token.length] = 0;
586 write_exp_elt_opcode (OP_SCOPE);
587 write_exp_elt_type (type);
588 write_exp_string (tmp_token);
589 write_exp_elt_opcode (OP_SCOPE);
593 variable: qualified_name
596 char *name = copy_name ($2);
598 struct minimal_symbol *msymbol;
601 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
604 write_exp_elt_opcode (OP_VAR_VALUE);
605 write_exp_elt_sym (sym);
606 write_exp_elt_opcode (OP_VAR_VALUE);
610 msymbol = lookup_minimal_symbol (name,
611 (struct objfile *) NULL);
614 write_exp_elt_opcode (OP_LONG);
615 write_exp_elt_type (builtin_type_int);
616 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
617 write_exp_elt_opcode (OP_LONG);
618 write_exp_elt_opcode (UNOP_MEMVAL);
619 if (msymbol -> type == mst_data ||
620 msymbol -> type == mst_bss)
621 write_exp_elt_type (builtin_type_int);
622 else if (msymbol -> type == mst_text)
623 write_exp_elt_type (lookup_function_type (builtin_type_int));
625 write_exp_elt_type (builtin_type_char);
626 write_exp_elt_opcode (UNOP_MEMVAL);
629 if (!have_full_symbols () && !have_partial_symbols ())
630 error ("No symbol table is loaded. Use the \"file\" command.");
632 error ("No symbol \"%s\" in current context.", name);
636 variable: name_not_typename
637 { struct symbol *sym = $1.sym;
641 switch (SYMBOL_CLASS (sym))
649 if (innermost_block == 0 ||
650 contained_in (block_found,
652 innermost_block = block_found;
659 case LOC_CONST_BYTES:
661 /* In this case the expression can
662 be evaluated regardless of what
663 frame we are in, so there is no
664 need to check for the
665 innermost_block. These cases are
666 listed so that gcc -Wall will
667 report types that may not have
672 write_exp_elt_opcode (OP_VAR_VALUE);
673 write_exp_elt_sym (sym);
674 write_exp_elt_opcode (OP_VAR_VALUE);
676 else if ($1.is_a_field_of_this)
678 /* C++: it hangs off of `this'. Must
679 not inadvertently convert from a method call
681 if (innermost_block == 0 ||
682 contained_in (block_found, innermost_block))
683 innermost_block = block_found;
684 write_exp_elt_opcode (OP_THIS);
685 write_exp_elt_opcode (OP_THIS);
686 write_exp_elt_opcode (STRUCTOP_PTR);
687 write_exp_string ($1.stoken);
688 write_exp_elt_opcode (STRUCTOP_PTR);
692 struct minimal_symbol *msymbol;
693 register char *arg = copy_name ($1.stoken);
695 msymbol = lookup_minimal_symbol (arg,
696 (struct objfile *) NULL);
699 write_exp_elt_opcode (OP_LONG);
700 write_exp_elt_type (builtin_type_int);
701 write_exp_elt_longcst ((LONGEST) SYMBOL_VALUE_ADDRESS (msymbol));
702 write_exp_elt_opcode (OP_LONG);
703 write_exp_elt_opcode (UNOP_MEMVAL);
704 if (msymbol -> type == mst_data ||
705 msymbol -> type == mst_bss)
706 write_exp_elt_type (builtin_type_int);
707 else if (msymbol -> type == mst_text)
708 write_exp_elt_type (lookup_function_type (builtin_type_int));
710 write_exp_elt_type (builtin_type_char);
711 write_exp_elt_opcode (UNOP_MEMVAL);
713 else if (!have_full_symbols () && !have_partial_symbols ())
714 error ("No symbol table is loaded. Use the \"file\" command.");
716 error ("No symbol \"%s\" in current context.",
717 copy_name ($1.stoken));
726 /* This is where the interesting stuff happens. */
729 struct type *follow_type = $1;
730 struct type *range_type;
739 follow_type = lookup_pointer_type (follow_type);
742 follow_type = lookup_reference_type (follow_type);
745 array_size = pop_type_int ();
746 if (array_size != -1)
749 create_range_type ((struct type *) NULL,
753 create_array_type ((struct type *) NULL,
754 follow_type, range_type);
757 follow_type = lookup_pointer_type (follow_type);
760 follow_type = lookup_function_type (follow_type);
768 { push_type (tp_pointer); $$ = 0; }
770 { push_type (tp_pointer); $$ = $2; }
772 { push_type (tp_reference); $$ = 0; }
774 { push_type (tp_reference); $$ = $2; }
778 direct_abs_decl: '(' abs_decl ')'
780 | direct_abs_decl array_mod
783 push_type (tp_array);
788 push_type (tp_array);
791 | direct_abs_decl func_mod
792 { push_type (tp_function); }
794 { push_type (tp_function); }
805 | '(' nonempty_typelist ')'
806 { free ((PTR)$2); $$ = 0; }
810 | typebase COLONCOLON '*'
811 { $$ = lookup_member_type (builtin_type_int, $1); }
812 | type '(' typebase COLONCOLON '*' ')'
813 { $$ = lookup_member_type ($1, $3); }
814 | type '(' typebase COLONCOLON '*' ')' '(' ')'
815 { $$ = lookup_member_type
816 (lookup_function_type ($1), $3); }
817 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
818 { $$ = lookup_member_type
819 (lookup_function_type ($1), $3);
823 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
827 { $$ = builtin_type_int; }
829 { $$ = builtin_type_long; }
831 { $$ = builtin_type_short; }
833 { $$ = builtin_type_long; }
834 | UNSIGNED LONG INT_KEYWORD
835 { $$ = builtin_type_unsigned_long; }
837 { $$ = builtin_type_long_long; }
838 | LONG LONG INT_KEYWORD
839 { $$ = builtin_type_long_long; }
841 { $$ = builtin_type_unsigned_long_long; }
842 | UNSIGNED LONG LONG INT_KEYWORD
843 { $$ = builtin_type_unsigned_long_long; }
845 { $$ = builtin_type_short; }
846 | UNSIGNED SHORT INT_KEYWORD
847 { $$ = builtin_type_unsigned_short; }
849 { $$ = lookup_struct (copy_name ($2),
850 expression_context_block); }
852 { $$ = lookup_struct (copy_name ($2),
853 expression_context_block); }
855 { $$ = lookup_union (copy_name ($2),
856 expression_context_block); }
858 { $$ = lookup_enum (copy_name ($2),
859 expression_context_block); }
861 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
863 { $$ = builtin_type_unsigned_int; }
864 | SIGNED_KEYWORD typename
865 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
867 { $$ = builtin_type_int; }
868 | TEMPLATE name '<' type '>'
869 { $$ = lookup_template_type(copy_name($2), $4,
870 expression_context_block);
872 /* "const" and "volatile" are curently ignored. */
873 | CONST_KEYWORD typebase { $$ = $2; }
874 | VOLATILE_KEYWORD typebase { $$ = $2; }
880 $$.stoken.ptr = "int";
881 $$.stoken.length = 3;
882 $$.type = builtin_type_int;
886 $$.stoken.ptr = "long";
887 $$.stoken.length = 4;
888 $$.type = builtin_type_long;
892 $$.stoken.ptr = "short";
893 $$.stoken.length = 5;
894 $$.type = builtin_type_short;
900 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
901 $<ivec>$[0] = 1; /* Number of types in vector */
904 | nonempty_typelist ',' type
905 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
906 $$ = (struct type **) realloc ((char *) $1, len);
907 $$[$<ivec>$[0]] = $3;
911 name : NAME { $$ = $1.stoken; }
912 | BLOCKNAME { $$ = $1.stoken; }
913 | TYPENAME { $$ = $1.stoken; }
914 | NAME_OR_INT { $$ = $1.stoken; }
917 name_not_typename : NAME
919 /* These would be useful if name_not_typename was useful, but it is just
920 a fake for "variable", so these cause reduce/reduce conflicts because
921 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
922 =exp) or just an exp. If name_not_typename was ever used in an lvalue
923 context where only a name could occur, this might be useful.
930 /* Take care of parsing a number (anything that starts with a digit).
931 Set yylval and return the token type; update lexptr.
932 LEN is the number of characters in it. */
934 /*** Needs some error checking for the float case ***/
937 parse_number (p, len, parsed_float, putithere)
943 register LONGEST n = 0;
944 register LONGEST prevn = 0;
947 register int base = input_radix;
951 struct type *signed_type;
952 struct type *unsigned_type;
956 /* It's a float since it contains a point or an exponent. */
957 putithere->dval = atof (p);
961 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
995 if (c >= 'A' && c <= 'Z')
997 if (c != 'l' && c != 'u')
999 if (c >= '0' && c <= '9')
1003 if (base > 10 && c >= 'a' && c <= 'f')
1004 n += i = c - 'a' + 10;
1005 else if (len == 0 && c == 'l')
1007 else if (len == 0 && c == 'u')
1010 return ERROR; /* Char not a digit */
1013 return ERROR; /* Invalid digit in this base */
1015 /* Portably test for overflow (only works for nonzero values, so make
1016 a second check for zero). */
1017 if((prevn >= n) && n != 0)
1018 unsigned_p=1; /* Try something unsigned */
1019 /* If range checking enabled, portably test for unsigned overflow. */
1020 if(RANGE_CHECK && n!=0)
1022 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1023 range_error("Overflow on numeric constant.");
1028 /* If the number is too big to be an int, or it's got an l suffix
1029 then it's a long. Work out if this has to be a long by
1030 shifting right and and seeing if anything remains, and the
1031 target int size is different to the target long size. */
1033 if ((TARGET_INT_BIT != TARGET_LONG_BIT && (n >> TARGET_INT_BIT)) || long_p)
1035 high_bit = ((LONGEST)1) << (TARGET_LONG_BIT-1);
1036 unsigned_type = builtin_type_unsigned_long;
1037 signed_type = builtin_type_long;
1041 high_bit = ((LONGEST)1) << (TARGET_INT_BIT-1);
1042 unsigned_type = builtin_type_unsigned_int;
1043 signed_type = builtin_type_int;
1046 putithere->typed_val.val = n;
1048 /* If the high bit of the worked out type is set then this number
1049 has to be unsigned. */
1051 if (unsigned_p || (n & high_bit))
1053 putithere->typed_val.type = unsigned_type;
1057 putithere->typed_val.type = signed_type;
1067 enum exp_opcode opcode;
1070 static const struct token tokentab3[] =
1072 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1073 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1076 static const struct token tokentab2[] =
1078 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1079 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1080 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1081 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1082 {"%=", ASSIGN_MODIFY, BINOP_REM},
1083 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1084 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1085 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1086 {"++", INCREMENT, BINOP_END},
1087 {"--", DECREMENT, BINOP_END},
1088 {"->", ARROW, BINOP_END},
1089 {"&&", ANDAND, BINOP_END},
1090 {"||", OROR, BINOP_END},
1091 {"::", COLONCOLON, BINOP_END},
1092 {"<<", LSH, BINOP_END},
1093 {">>", RSH, BINOP_END},
1094 {"==", EQUAL, BINOP_END},
1095 {"!=", NOTEQUAL, BINOP_END},
1096 {"<=", LEQ, BINOP_END},
1097 {">=", GEQ, BINOP_END}
1100 /* Read one token, getting characters through lexptr. */
1111 static char *tempbuf;
1112 static int tempbufsize;
1117 /* See if it is a special token of length 3. */
1118 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1119 if (STREQN (tokstart, tokentab3[i].operator, 3))
1122 yylval.opcode = tokentab3[i].opcode;
1123 return tokentab3[i].token;
1126 /* See if it is a special token of length 2. */
1127 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1128 if (STREQN (tokstart, tokentab2[i].operator, 2))
1131 yylval.opcode = tokentab2[i].opcode;
1132 return tokentab2[i].token;
1135 switch (c = *tokstart)
1147 /* We either have a character constant ('0' or '\177' for example)
1148 or we have a quoted symbol reference ('foo(int,int)' in C++
1153 c = parse_escape (&lexptr);
1155 yylval.typed_val.val = c;
1156 yylval.typed_val.type = builtin_type_char;
1161 namelen = skip_quoted (tokstart) - tokstart;
1164 lexptr = tokstart + namelen;
1169 error ("Invalid character constant.");
1179 if (paren_depth == 0)
1186 if (comma_terminates && paren_depth == 0)
1192 /* Might be a floating point number. */
1193 if (lexptr[1] < '0' || lexptr[1] > '9')
1194 goto symbol; /* Nope, must be a symbol. */
1195 /* FALL THRU into number case. */
1208 /* It's a number. */
1209 int got_dot = 0, got_e = 0, toktype;
1210 register char *p = tokstart;
1211 int hex = input_radix > 10;
1213 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1218 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1226 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1227 got_dot = got_e = 1;
1228 else if (!hex && !got_dot && *p == '.')
1230 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1231 && (*p == '-' || *p == '+'))
1232 /* This is the sign of the exponent, not the end of the
1235 /* We will take any letters or digits. parse_number will
1236 complain if past the radix, or if L or U are not final. */
1237 else if ((*p < '0' || *p > '9')
1238 && ((*p < 'a' || *p > 'z')
1239 && (*p < 'A' || *p > 'Z')))
1242 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1243 if (toktype == ERROR)
1245 char *err_copy = (char *) alloca (p - tokstart + 1);
1247 memcpy (err_copy, tokstart, p - tokstart);
1248 err_copy[p - tokstart] = 0;
1249 error ("Invalid number \"%s\".", err_copy);
1281 /* Build the gdb internal form of the input string in tempbuf,
1282 translating any standard C escape forms seen. Note that the
1283 buffer is null byte terminated *only* for the convenience of
1284 debugging gdb itself and printing the buffer contents when
1285 the buffer contains no embedded nulls. Gdb does not depend
1286 upon the buffer being null byte terminated, it uses the length
1287 string instead. This allows gdb to handle C strings (as well
1288 as strings in other languages) with embedded null bytes */
1290 tokptr = ++tokstart;
1294 /* Grow the static temp buffer if necessary, including allocating
1295 the first one on demand. */
1296 if (tempbufindex + 1 >= tempbufsize)
1298 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1304 /* Do nothing, loop will terminate. */
1308 c = parse_escape (&tokptr);
1313 tempbuf[tempbufindex++] = c;
1316 tempbuf[tempbufindex++] = *tokptr++;
1319 } while ((*tokptr != '"') && (*tokptr != '\0'));
1320 if (*tokptr++ != '"')
1322 error ("Unterminated string in expression.");
1324 tempbuf[tempbufindex] = '\0'; /* See note above */
1325 yylval.sval.ptr = tempbuf;
1326 yylval.sval.length = tempbufindex;
1331 if (!(c == '_' || c == '$'
1332 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1333 /* We must have come across a bad character (e.g. ';'). */
1334 error ("Invalid character '%c' in expression.", c);
1336 /* It's a name. See how long it is. */
1338 for (c = tokstart[namelen];
1339 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1340 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1341 c = tokstart[++namelen])
1344 /* The token "if" terminates the expression and is NOT
1345 removed from the input stream. */
1346 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1353 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1354 and $$digits (equivalent to $<-digits> if you could type that).
1355 Make token type LAST, and put the number (the digits) in yylval. */
1358 if (*tokstart == '$')
1360 register int negate = 0;
1362 /* Double dollar means negate the number and add -1 as well.
1363 Thus $$ alone means -1. */
1364 if (namelen >= 2 && tokstart[1] == '$')
1371 /* Just dollars (one or two) */
1372 yylval.lval = - negate;
1375 /* Is the rest of the token digits? */
1376 for (; c < namelen; c++)
1377 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1381 yylval.lval = atoi (tokstart + 1 + negate);
1383 yylval.lval = - yylval.lval;
1388 /* Handle tokens that refer to machine registers:
1389 $ followed by a register name. */
1391 if (*tokstart == '$') {
1392 for (c = 0; c < NUM_REGS; c++)
1393 if (namelen - 1 == strlen (reg_names[c])
1394 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1399 for (c = 0; c < num_std_regs; c++)
1400 if (namelen - 1 == strlen (std_regs[c].name)
1401 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1403 yylval.lval = std_regs[c].regnum;
1407 /* Catch specific keywords. Should be done with a data structure. */
1411 if (STREQN (tokstart, "unsigned", 8))
1413 if (current_language->la_language == language_cplus
1414 && STREQN (tokstart, "template", 8))
1416 if (STREQN (tokstart, "volatile", 8))
1417 return VOLATILE_KEYWORD;
1420 if (STREQN (tokstart, "struct", 6))
1422 if (STREQN (tokstart, "signed", 6))
1423 return SIGNED_KEYWORD;
1424 if (STREQN (tokstart, "sizeof", 6))
1428 if (current_language->la_language == language_cplus
1429 && STREQN (tokstart, "class", 5))
1431 if (STREQN (tokstart, "union", 5))
1433 if (STREQN (tokstart, "short", 5))
1435 if (STREQN (tokstart, "const", 5))
1436 return CONST_KEYWORD;
1439 if (STREQN (tokstart, "enum", 4))
1441 if (STREQN (tokstart, "long", 4))
1443 if (current_language->la_language == language_cplus
1444 && STREQN (tokstart, "this", 4))
1446 static const char this_name[] =
1447 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1449 if (lookup_symbol (this_name, expression_context_block,
1450 VAR_NAMESPACE, 0, NULL))
1455 if (STREQN (tokstart, "int", 3))
1462 yylval.sval.ptr = tokstart;
1463 yylval.sval.length = namelen;
1465 /* Any other names starting in $ are debugger internal variables. */
1467 if (*tokstart == '$')
1469 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1473 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1474 functions or symtabs. If this is not so, then ...
1475 Use token-type TYPENAME for symbols that happen to be defined
1476 currently as names of types; NAME for other symbols.
1477 The caller is not constrained to care about the distinction. */
1479 char *tmp = copy_name (yylval.sval);
1481 int is_a_field_of_this = 0;
1484 sym = lookup_symbol (tmp, expression_context_block,
1486 current_language->la_language == language_cplus
1487 ? &is_a_field_of_this : NULL,
1489 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1490 lookup_partial_symtab (tmp))
1492 yylval.ssym.sym = sym;
1493 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1496 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1498 yylval.tsym.type = SYMBOL_TYPE (sym);
1501 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1504 /* Input names that aren't symbols but ARE valid hex numbers,
1505 when the input radix permits them, can be names or numbers
1506 depending on the parse. Note we support radixes > 16 here. */
1508 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1509 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1511 YYSTYPE newlval; /* Its value is ignored. */
1512 hextype = parse_number (tokstart, namelen, 0, &newlval);
1515 yylval.ssym.sym = sym;
1516 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1521 /* Any other kind of symbol */
1522 yylval.ssym.sym = sym;
1523 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1532 error (msg ? msg : "Invalid syntax in expression.");