1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Parse a C expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
42 #include "expression.h"
44 #include "parser-defs.h"
47 #include "bfd.h" /* Required by objfiles.h. */
48 #include "symfile.h" /* Required by objfiles.h. */
49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
51 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
52 as well as gratuitiously global symbol names, so we can have multiple
53 yacc generated parsers in gdb. Note that these are only the variables
54 produced by yacc. If other parser generators (bison, byacc, etc) produce
55 additional global names that conflict at link time, then those parser
56 generators need to be fixed instead of adding those names to this list. */
58 #define yymaxdepth c_maxdepth
59 #define yyparse c_parse
61 #define yyerror c_error
64 #define yydebug c_debug
73 #define yyerrflag c_errflag
74 #define yynerrs c_nerrs
79 #define yystate c_state
85 #define yyreds c_reds /* With YYDEBUG defined */
86 #define yytoks c_toks /* With YYDEBUG defined */
89 #define yydefred c_yydefred
90 #define yydgoto c_yydgoto
91 #define yysindex c_yysindex
92 #define yyrindex c_yyrindex
93 #define yygindex c_yygindex
94 #define yytable c_yytable
95 #define yycheck c_yycheck
98 #define YYDEBUG 0 /* Default to no yydebug support */
102 yyparse PARAMS ((void));
105 yylex PARAMS ((void));
108 yyerror PARAMS ((char *));
112 /* Although the yacc "value" of an expression is not used,
113 since the result is stored in the structure being created,
114 other node types do have values. */
128 struct symtoken ssym;
131 enum exp_opcode opcode;
132 struct internalvar *ivar;
139 /* YYSTYPE gets defined by %union */
141 parse_number PARAMS ((char *, int, int, YYSTYPE *));
144 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
146 %type <tval> type typebase
147 %type <tvec> nonempty_typelist
148 /* %type <bval> block */
150 /* Fancy type parsing. */
151 %type <voidval> func_mod direct_abs_decl abs_decl
153 %type <lval> array_mod
155 %token <typed_val> INT
158 /* Both NAME and TYPENAME tokens represent symbols in the input,
159 and both convey their data as strings.
160 But a TYPENAME is a string that happens to be defined as a typedef
161 or builtin type name (such as int or char)
162 and a NAME is any other symbol.
163 Contexts where this distinction is not important can use the
164 nonterminal "name", which matches either NAME or TYPENAME. */
167 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
168 %token <tsym> TYPENAME
170 %type <ssym> name_not_typename
171 %type <tsym> typename
173 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
174 but which would parse as a valid number in the current input radix.
175 E.g. "c" when input_radix==16. Depending on the parse, it will be
176 turned into a name or into a number. */
178 %token <ssym> NAME_OR_INT
180 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
184 /* Special type cases, put in to allow the parser to distinguish different
186 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD
187 %token <lval> LAST REGNAME
189 %token <ivar> VARIABLE
191 %token <opcode> ASSIGN_MODIFY
198 %right '=' ASSIGN_MODIFY
206 %left '<' '>' LEQ GEQ
211 %right UNARY INCREMENT DECREMENT
212 %right ARROW '.' '[' '('
213 %token <ssym> BLOCKNAME
225 { write_exp_elt_opcode(OP_TYPE);
226 write_exp_elt_type($1);
227 write_exp_elt_opcode(OP_TYPE);}
230 /* Expressions, including the comma operator. */
233 { write_exp_elt_opcode (BINOP_COMMA); }
236 /* Expressions, not including the comma operator. */
237 exp : '*' exp %prec UNARY
238 { write_exp_elt_opcode (UNOP_IND); }
240 exp : '&' exp %prec UNARY
241 { write_exp_elt_opcode (UNOP_ADDR); }
243 exp : '-' exp %prec UNARY
244 { write_exp_elt_opcode (UNOP_NEG); }
247 exp : '!' exp %prec UNARY
248 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
251 exp : '~' exp %prec UNARY
252 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
255 exp : INCREMENT exp %prec UNARY
256 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
259 exp : DECREMENT exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
263 exp : exp INCREMENT %prec UNARY
264 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
267 exp : exp DECREMENT %prec UNARY
268 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
271 exp : SIZEOF exp %prec UNARY
272 { write_exp_elt_opcode (UNOP_SIZEOF); }
276 { write_exp_elt_opcode (STRUCTOP_PTR);
277 write_exp_string ($3);
278 write_exp_elt_opcode (STRUCTOP_PTR); }
281 exp : exp ARROW qualified_name
282 { /* exp->type::name becomes exp->*(&type::name) */
283 /* Note: this doesn't work if name is a
284 static member! FIXME */
285 write_exp_elt_opcode (UNOP_ADDR);
286 write_exp_elt_opcode (STRUCTOP_MPTR); }
288 exp : exp ARROW '*' exp
289 { write_exp_elt_opcode (STRUCTOP_MPTR); }
293 { write_exp_elt_opcode (STRUCTOP_STRUCT);
294 write_exp_string ($3);
295 write_exp_elt_opcode (STRUCTOP_STRUCT); }
298 exp : exp '.' qualified_name
299 { /* exp.type::name becomes exp.*(&type::name) */
300 /* Note: this doesn't work if name is a
301 static member! FIXME */
302 write_exp_elt_opcode (UNOP_ADDR);
303 write_exp_elt_opcode (STRUCTOP_MEMBER); }
306 exp : exp '.' '*' exp
307 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
310 exp : exp '[' exp1 ']'
311 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
315 /* This is to save the value of arglist_len
316 being accumulated by an outer function call. */
317 { start_arglist (); }
318 arglist ')' %prec ARROW
319 { write_exp_elt_opcode (OP_FUNCALL);
320 write_exp_elt_longcst ((LONGEST) end_arglist ());
321 write_exp_elt_opcode (OP_FUNCALL); }
325 { start_arglist (); }
335 arglist : arglist ',' exp %prec ABOVE_COMMA
340 { $$ = end_arglist () - 1; }
342 exp : lcurly arglist rcurly %prec ARROW
343 { write_exp_elt_opcode (OP_ARRAY);
344 write_exp_elt_longcst ((LONGEST) 0);
345 write_exp_elt_longcst ((LONGEST) $3);
346 write_exp_elt_opcode (OP_ARRAY); }
349 exp : lcurly type rcurly exp %prec UNARY
350 { write_exp_elt_opcode (UNOP_MEMVAL);
351 write_exp_elt_type ($2);
352 write_exp_elt_opcode (UNOP_MEMVAL); }
355 exp : '(' type ')' exp %prec UNARY
356 { write_exp_elt_opcode (UNOP_CAST);
357 write_exp_elt_type ($2);
358 write_exp_elt_opcode (UNOP_CAST); }
365 /* Binary operators in order of decreasing precedence. */
368 { write_exp_elt_opcode (BINOP_REPEAT); }
372 { write_exp_elt_opcode (BINOP_MUL); }
376 { write_exp_elt_opcode (BINOP_DIV); }
380 { write_exp_elt_opcode (BINOP_REM); }
384 { write_exp_elt_opcode (BINOP_ADD); }
388 { write_exp_elt_opcode (BINOP_SUB); }
392 { write_exp_elt_opcode (BINOP_LSH); }
396 { write_exp_elt_opcode (BINOP_RSH); }
400 { write_exp_elt_opcode (BINOP_EQUAL); }
403 exp : exp NOTEQUAL exp
404 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
408 { write_exp_elt_opcode (BINOP_LEQ); }
412 { write_exp_elt_opcode (BINOP_GEQ); }
416 { write_exp_elt_opcode (BINOP_LESS); }
420 { write_exp_elt_opcode (BINOP_GTR); }
424 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
428 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
432 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
436 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
440 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
443 exp : exp '?' exp ':' exp %prec '?'
444 { write_exp_elt_opcode (TERNOP_COND); }
448 { write_exp_elt_opcode (BINOP_ASSIGN); }
451 exp : exp ASSIGN_MODIFY exp
452 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
453 write_exp_elt_opcode ($2);
454 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
458 { write_exp_elt_opcode (OP_LONG);
459 write_exp_elt_type ($1.type);
460 write_exp_elt_longcst ((LONGEST)($1.val));
461 write_exp_elt_opcode (OP_LONG); }
466 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
467 write_exp_elt_opcode (OP_LONG);
468 write_exp_elt_type (val.typed_val.type);
469 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
470 write_exp_elt_opcode (OP_LONG);
476 { write_exp_elt_opcode (OP_DOUBLE);
477 write_exp_elt_type (builtin_type_double);
478 write_exp_elt_dblcst ($1);
479 write_exp_elt_opcode (OP_DOUBLE); }
486 { write_exp_elt_opcode (OP_LAST);
487 write_exp_elt_longcst ((LONGEST) $1);
488 write_exp_elt_opcode (OP_LAST); }
492 { write_exp_elt_opcode (OP_REGISTER);
493 write_exp_elt_longcst ((LONGEST) $1);
494 write_exp_elt_opcode (OP_REGISTER); }
498 { write_exp_elt_opcode (OP_INTERNALVAR);
499 write_exp_elt_intern ($1);
500 write_exp_elt_opcode (OP_INTERNALVAR); }
503 exp : SIZEOF '(' type ')' %prec UNARY
504 { write_exp_elt_opcode (OP_LONG);
505 write_exp_elt_type (builtin_type_int);
506 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
507 write_exp_elt_opcode (OP_LONG); }
511 { /* C strings are converted into array constants with
512 an explicit null byte added at the end. Thus
513 the array upper bound is the string length.
514 There is no such thing in C as a completely empty
516 char *sp = $1.ptr; int count = $1.length;
519 write_exp_elt_opcode (OP_LONG);
520 write_exp_elt_type (builtin_type_char);
521 write_exp_elt_longcst ((LONGEST)(*sp++));
522 write_exp_elt_opcode (OP_LONG);
524 write_exp_elt_opcode (OP_LONG);
525 write_exp_elt_type (builtin_type_char);
526 write_exp_elt_longcst ((LONGEST)'\0');
527 write_exp_elt_opcode (OP_LONG);
528 write_exp_elt_opcode (OP_ARRAY);
529 write_exp_elt_longcst ((LONGEST) 0);
530 write_exp_elt_longcst ((LONGEST) ($1.length));
531 write_exp_elt_opcode (OP_ARRAY); }
536 { write_exp_elt_opcode (OP_THIS);
537 write_exp_elt_opcode (OP_THIS); }
545 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
549 lookup_symtab (copy_name ($1.stoken));
551 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
553 error ("No file or function \"%s\".",
554 copy_name ($1.stoken));
559 block : block COLONCOLON name
561 = lookup_symbol (copy_name ($3), $1,
562 VAR_NAMESPACE, (int *) NULL,
563 (struct symtab **) NULL);
564 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
565 error ("No function \"%s\" in specified context.",
567 $$ = SYMBOL_BLOCK_VALUE (tem); }
570 variable: block COLONCOLON name
571 { struct symbol *sym;
572 sym = lookup_symbol (copy_name ($3), $1,
573 VAR_NAMESPACE, (int *) NULL,
574 (struct symtab **) NULL);
576 error ("No symbol \"%s\" in specified context.",
579 write_exp_elt_opcode (OP_VAR_VALUE);
580 /* block_found is set by lookup_symbol. */
581 write_exp_elt_block (block_found);
582 write_exp_elt_sym (sym);
583 write_exp_elt_opcode (OP_VAR_VALUE); }
586 qualified_name: typebase COLONCOLON name
588 struct type *type = $1;
589 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
590 && TYPE_CODE (type) != TYPE_CODE_UNION)
591 error ("`%s' is not defined as an aggregate type.",
594 write_exp_elt_opcode (OP_SCOPE);
595 write_exp_elt_type (type);
596 write_exp_string ($3);
597 write_exp_elt_opcode (OP_SCOPE);
599 | typebase COLONCOLON '~' name
601 struct type *type = $1;
602 struct stoken tmp_token;
603 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
604 && TYPE_CODE (type) != TYPE_CODE_UNION)
605 error ("`%s' is not defined as an aggregate type.",
608 if (!STREQ (type_name_no_tag (type), $4.ptr))
609 error ("invalid destructor `%s::~%s'",
610 type_name_no_tag (type), $4.ptr);
612 tmp_token.ptr = (char*) alloca ($4.length + 2);
613 tmp_token.length = $4.length + 1;
614 tmp_token.ptr[0] = '~';
615 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
616 tmp_token.ptr[tmp_token.length] = 0;
617 write_exp_elt_opcode (OP_SCOPE);
618 write_exp_elt_type (type);
619 write_exp_string (tmp_token);
620 write_exp_elt_opcode (OP_SCOPE);
624 variable: qualified_name
627 char *name = copy_name ($2);
629 struct minimal_symbol *msymbol;
632 lookup_symbol (name, (const struct block *) NULL,
633 VAR_NAMESPACE, (int *) NULL,
634 (struct symtab **) NULL);
637 write_exp_elt_opcode (OP_VAR_VALUE);
638 write_exp_elt_block (NULL);
639 write_exp_elt_sym (sym);
640 write_exp_elt_opcode (OP_VAR_VALUE);
644 msymbol = lookup_minimal_symbol (name, NULL, NULL);
647 write_exp_msymbol (msymbol,
648 lookup_function_type (builtin_type_int),
652 if (!have_full_symbols () && !have_partial_symbols ())
653 error ("No symbol table is loaded. Use the \"file\" command.");
655 error ("No symbol \"%s\" in current context.", name);
659 variable: name_not_typename
660 { struct symbol *sym = $1.sym;
664 if (symbol_read_needs_frame (sym))
666 if (innermost_block == 0 ||
667 contained_in (block_found,
669 innermost_block = block_found;
672 write_exp_elt_opcode (OP_VAR_VALUE);
673 /* We want to use the selected frame, not
674 another more inner frame which happens to
675 be in the same block. */
676 write_exp_elt_block (NULL);
677 write_exp_elt_sym (sym);
678 write_exp_elt_opcode (OP_VAR_VALUE);
680 else if ($1.is_a_field_of_this)
682 /* C++: it hangs off of `this'. Must
683 not inadvertently convert from a method call
685 if (innermost_block == 0 ||
686 contained_in (block_found, innermost_block))
687 innermost_block = block_found;
688 write_exp_elt_opcode (OP_THIS);
689 write_exp_elt_opcode (OP_THIS);
690 write_exp_elt_opcode (STRUCTOP_PTR);
691 write_exp_string ($1.stoken);
692 write_exp_elt_opcode (STRUCTOP_PTR);
696 struct minimal_symbol *msymbol;
697 register char *arg = copy_name ($1.stoken);
700 lookup_minimal_symbol (arg, NULL, NULL);
703 write_exp_msymbol (msymbol,
704 lookup_function_type (builtin_type_int),
707 else if (!have_full_symbols () && !have_partial_symbols ())
708 error ("No symbol table is loaded. Use the \"file\" command.");
710 error ("No symbol \"%s\" in current context.",
711 copy_name ($1.stoken));
718 /* "const" and "volatile" are curently ignored. A type qualifier
719 before the type is currently handled in the typebase rule.
720 The reason for recognizing these here (shift/reduce conflicts)
721 might be obsolete now that some pointer to member rules have
723 | typebase CONST_KEYWORD
724 | typebase VOLATILE_KEYWORD
726 { $$ = follow_types ($1); }
727 | typebase CONST_KEYWORD abs_decl
728 { $$ = follow_types ($1); }
729 | typebase VOLATILE_KEYWORD abs_decl
730 { $$ = follow_types ($1); }
734 { push_type (tp_pointer); $$ = 0; }
736 { push_type (tp_pointer); $$ = $2; }
738 { push_type (tp_reference); $$ = 0; }
740 { push_type (tp_reference); $$ = $2; }
744 direct_abs_decl: '(' abs_decl ')'
746 | direct_abs_decl array_mod
749 push_type (tp_array);
754 push_type (tp_array);
758 | direct_abs_decl func_mod
759 { push_type (tp_function); }
761 { push_type (tp_function); }
772 | '(' nonempty_typelist ')'
773 { free ((PTR)$2); $$ = 0; }
776 /* We used to try to recognize more pointer to member types here, but
777 that didn't work (shift/reduce conflicts meant that these rules never
778 got executed). The problem is that
779 int (foo::bar::baz::bizzle)
780 is a function type but
781 int (foo::bar::baz::bizzle::*)
782 is a pointer to member type. Stroustrup loses again! */
785 | typebase COLONCOLON '*'
786 { $$ = lookup_member_type (builtin_type_int, $1); }
789 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
793 { $$ = builtin_type_int; }
795 { $$ = builtin_type_long; }
797 { $$ = builtin_type_short; }
799 { $$ = builtin_type_long; }
800 | UNSIGNED LONG INT_KEYWORD
801 { $$ = builtin_type_unsigned_long; }
803 { $$ = builtin_type_long_long; }
804 | LONG LONG INT_KEYWORD
805 { $$ = builtin_type_long_long; }
807 { $$ = builtin_type_unsigned_long_long; }
808 | UNSIGNED LONG LONG INT_KEYWORD
809 { $$ = builtin_type_unsigned_long_long; }
811 { $$ = builtin_type_short; }
812 | UNSIGNED SHORT INT_KEYWORD
813 { $$ = builtin_type_unsigned_short; }
815 { $$ = lookup_struct (copy_name ($2),
816 expression_context_block); }
818 { $$ = lookup_struct (copy_name ($2),
819 expression_context_block); }
821 { $$ = lookup_union (copy_name ($2),
822 expression_context_block); }
824 { $$ = lookup_enum (copy_name ($2),
825 expression_context_block); }
827 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
829 { $$ = builtin_type_unsigned_int; }
830 | SIGNED_KEYWORD typename
831 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
833 { $$ = builtin_type_int; }
834 | TEMPLATE name '<' type '>'
835 { $$ = lookup_template_type(copy_name($2), $4,
836 expression_context_block);
838 /* "const" and "volatile" are curently ignored. A type qualifier
839 after the type is handled in the ptype rule. I think these could
841 | CONST_KEYWORD typebase { $$ = $2; }
842 | VOLATILE_KEYWORD typebase { $$ = $2; }
848 $$.stoken.ptr = "int";
849 $$.stoken.length = 3;
850 $$.type = builtin_type_int;
854 $$.stoken.ptr = "long";
855 $$.stoken.length = 4;
856 $$.type = builtin_type_long;
860 $$.stoken.ptr = "short";
861 $$.stoken.length = 5;
862 $$.type = builtin_type_short;
868 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
869 $<ivec>$[0] = 1; /* Number of types in vector */
872 | nonempty_typelist ',' type
873 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
874 $$ = (struct type **) realloc ((char *) $1, len);
875 $$[$<ivec>$[0]] = $3;
879 name : NAME { $$ = $1.stoken; }
880 | BLOCKNAME { $$ = $1.stoken; }
881 | TYPENAME { $$ = $1.stoken; }
882 | NAME_OR_INT { $$ = $1.stoken; }
885 name_not_typename : NAME
887 /* These would be useful if name_not_typename was useful, but it is just
888 a fake for "variable", so these cause reduce/reduce conflicts because
889 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
890 =exp) or just an exp. If name_not_typename was ever used in an lvalue
891 context where only a name could occur, this might be useful.
898 /* Take care of parsing a number (anything that starts with a digit).
899 Set yylval and return the token type; update lexptr.
900 LEN is the number of characters in it. */
902 /*** Needs some error checking for the float case ***/
905 parse_number (p, len, parsed_float, putithere)
911 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
912 here, and we do kind of silly things like cast to unsigned. */
913 register LONGEST n = 0;
914 register LONGEST prevn = 0;
919 register int base = input_radix;
922 /* Number of "L" suffixes encountered. */
925 /* We have found a "L" or "U" suffix. */
926 int found_suffix = 0;
928 unsigned LONGEST high_bit;
929 struct type *signed_type;
930 struct type *unsigned_type;
934 /* It's a float since it contains a point or an exponent. */
935 putithere->dval = atof (p);
939 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
973 if (c >= 'A' && c <= 'Z')
975 if (c != 'l' && c != 'u')
977 if (c >= '0' && c <= '9')
985 if (base > 10 && c >= 'a' && c <= 'f')
989 n += i = c - 'a' + 10;
1002 return ERROR; /* Char not a digit */
1005 return ERROR; /* Invalid digit in this base */
1007 /* Portably test for overflow (only works for nonzero values, so make
1008 a second check for zero). FIXME: Can't we just make n and prevn
1009 unsigned and avoid this? */
1010 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1011 unsigned_p = 1; /* Try something unsigned */
1013 /* Portably test for unsigned overflow.
1014 FIXME: This check is wrong; for example it doesn't find overflow
1015 on 0x123456789 when LONGEST is 32 bits. */
1016 if (c != 'l' && c != 'u' && n != 0)
1018 if ((unsigned_p && (unsigned LONGEST) prevn >= (unsigned LONGEST) n))
1019 error ("Numeric constant too large.");
1024 /* An integer constant is an int, a long, or a long long. An L
1025 suffix forces it to be long; an LL suffix forces it to be long
1026 long. If not forced to a larger size, it gets the first type of
1027 the above that it fits in. To figure out whether it fits, we
1028 shift it right and see whether anything remains. Note that we
1029 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1030 operation, because many compilers will warn about such a shift
1031 (which always produces a zero result). Sometimes TARGET_INT_BIT
1032 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
1033 the case where it is we just always shift the value more than
1034 once, with fewer bits each time. */
1036 un = (unsigned LONGEST)n >> 2;
1038 && (un >> (TARGET_INT_BIT - 2)) == 0)
1040 high_bit = ((unsigned LONGEST)1) << (TARGET_INT_BIT-1);
1042 /* A large decimal (not hex or octal) constant (between INT_MAX
1043 and UINT_MAX) is a long or unsigned long, according to ANSI,
1044 never an unsigned int, but this code treats it as unsigned
1045 int. This probably should be fixed. GCC gives a warning on
1048 unsigned_type = builtin_type_unsigned_int;
1049 signed_type = builtin_type_int;
1051 else if (long_p <= 1
1052 && (un >> (TARGET_LONG_BIT - 2)) == 0)
1054 high_bit = ((unsigned LONGEST)1) << (TARGET_LONG_BIT-1);
1055 unsigned_type = builtin_type_unsigned_long;
1056 signed_type = builtin_type_long;
1060 high_bit = (((unsigned LONGEST)1)
1061 << (TARGET_LONG_LONG_BIT - 32 - 1)
1065 /* A long long does not fit in a LONGEST. */
1067 (unsigned LONGEST)1 << (sizeof (LONGEST) * HOST_CHAR_BIT - 1);
1068 unsigned_type = builtin_type_unsigned_long_long;
1069 signed_type = builtin_type_long_long;
1072 putithere->typed_val.val = n;
1074 /* If the high bit of the worked out type is set then this number
1075 has to be unsigned. */
1077 if (unsigned_p || (n & high_bit))
1079 putithere->typed_val.type = unsigned_type;
1083 putithere->typed_val.type = signed_type;
1093 enum exp_opcode opcode;
1096 static const struct token tokentab3[] =
1098 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1099 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1102 static const struct token tokentab2[] =
1104 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1105 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1106 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1107 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1108 {"%=", ASSIGN_MODIFY, BINOP_REM},
1109 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1110 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1111 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1112 {"++", INCREMENT, BINOP_END},
1113 {"--", DECREMENT, BINOP_END},
1114 {"->", ARROW, BINOP_END},
1115 {"&&", ANDAND, BINOP_END},
1116 {"||", OROR, BINOP_END},
1117 {"::", COLONCOLON, BINOP_END},
1118 {"<<", LSH, BINOP_END},
1119 {">>", RSH, BINOP_END},
1120 {"==", EQUAL, BINOP_END},
1121 {"!=", NOTEQUAL, BINOP_END},
1122 {"<=", LEQ, BINOP_END},
1123 {">=", GEQ, BINOP_END}
1126 /* Read one token, getting characters through lexptr. */
1137 static char *tempbuf;
1138 static int tempbufsize;
1143 /* See if it is a special token of length 3. */
1144 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1145 if (STREQN (tokstart, tokentab3[i].operator, 3))
1148 yylval.opcode = tokentab3[i].opcode;
1149 return tokentab3[i].token;
1152 /* See if it is a special token of length 2. */
1153 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1154 if (STREQN (tokstart, tokentab2[i].operator, 2))
1157 yylval.opcode = tokentab2[i].opcode;
1158 return tokentab2[i].token;
1161 switch (c = *tokstart)
1173 /* We either have a character constant ('0' or '\177' for example)
1174 or we have a quoted symbol reference ('foo(int,int)' in C++
1179 c = parse_escape (&lexptr);
1181 yylval.typed_val.val = c;
1182 yylval.typed_val.type = builtin_type_char;
1187 namelen = skip_quoted (tokstart) - tokstart;
1190 lexptr = tokstart + namelen;
1191 if (lexptr[-1] != '\'')
1192 error ("Unmatched single quote.");
1197 error ("Invalid character constant.");
1207 if (paren_depth == 0)
1214 if (comma_terminates && paren_depth == 0)
1220 /* Might be a floating point number. */
1221 if (lexptr[1] < '0' || lexptr[1] > '9')
1222 goto symbol; /* Nope, must be a symbol. */
1223 /* FALL THRU into number case. */
1236 /* It's a number. */
1237 int got_dot = 0, got_e = 0, toktype;
1238 register char *p = tokstart;
1239 int hex = input_radix > 10;
1241 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1246 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1254 /* This test includes !hex because 'e' is a valid hex digit
1255 and thus does not indicate a floating point number when
1256 the radix is hex. */
1257 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1258 got_dot = got_e = 1;
1259 /* This test does not include !hex, because a '.' always indicates
1260 a decimal floating point number regardless of the radix. */
1261 else if (!got_dot && *p == '.')
1263 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1264 && (*p == '-' || *p == '+'))
1265 /* This is the sign of the exponent, not the end of the
1268 /* We will take any letters or digits. parse_number will
1269 complain if past the radix, or if L or U are not final. */
1270 else if ((*p < '0' || *p > '9')
1271 && ((*p < 'a' || *p > 'z')
1272 && (*p < 'A' || *p > 'Z')))
1275 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1276 if (toktype == ERROR)
1278 char *err_copy = (char *) alloca (p - tokstart + 1);
1280 memcpy (err_copy, tokstart, p - tokstart);
1281 err_copy[p - tokstart] = 0;
1282 error ("Invalid number \"%s\".", err_copy);
1314 /* Build the gdb internal form of the input string in tempbuf,
1315 translating any standard C escape forms seen. Note that the
1316 buffer is null byte terminated *only* for the convenience of
1317 debugging gdb itself and printing the buffer contents when
1318 the buffer contains no embedded nulls. Gdb does not depend
1319 upon the buffer being null byte terminated, it uses the length
1320 string instead. This allows gdb to handle C strings (as well
1321 as strings in other languages) with embedded null bytes */
1323 tokptr = ++tokstart;
1327 /* Grow the static temp buffer if necessary, including allocating
1328 the first one on demand. */
1329 if (tempbufindex + 1 >= tempbufsize)
1331 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1337 /* Do nothing, loop will terminate. */
1341 c = parse_escape (&tokptr);
1346 tempbuf[tempbufindex++] = c;
1349 tempbuf[tempbufindex++] = *tokptr++;
1352 } while ((*tokptr != '"') && (*tokptr != '\0'));
1353 if (*tokptr++ != '"')
1355 error ("Unterminated string in expression.");
1357 tempbuf[tempbufindex] = '\0'; /* See note above */
1358 yylval.sval.ptr = tempbuf;
1359 yylval.sval.length = tempbufindex;
1364 if (!(c == '_' || c == '$'
1365 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1366 /* We must have come across a bad character (e.g. ';'). */
1367 error ("Invalid character '%c' in expression.", c);
1369 /* It's a name. See how long it is. */
1371 for (c = tokstart[namelen];
1372 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1373 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1378 while (tokstart[++i] && tokstart[i] != '>');
1379 if (tokstart[i] == '>')
1382 c = tokstart[++namelen];
1385 /* The token "if" terminates the expression and is NOT
1386 removed from the input stream. */
1387 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1394 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1395 and $$digits (equivalent to $<-digits> if you could type that).
1396 Make token type LAST, and put the number (the digits) in yylval. */
1399 if (*tokstart == '$')
1401 register int negate = 0;
1403 /* Double dollar means negate the number and add -1 as well.
1404 Thus $$ alone means -1. */
1405 if (namelen >= 2 && tokstart[1] == '$')
1412 /* Just dollars (one or two) */
1413 yylval.lval = - negate;
1416 /* Is the rest of the token digits? */
1417 for (; c < namelen; c++)
1418 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1422 yylval.lval = atoi (tokstart + 1 + negate);
1424 yylval.lval = - yylval.lval;
1429 /* Handle tokens that refer to machine registers:
1430 $ followed by a register name. */
1432 if (*tokstart == '$') {
1433 for (c = 0; c < NUM_REGS; c++)
1434 if (namelen - 1 == strlen (reg_names[c])
1435 && STREQN (tokstart + 1, reg_names[c], namelen - 1))
1440 for (c = 0; c < num_std_regs; c++)
1441 if (namelen - 1 == strlen (std_regs[c].name)
1442 && STREQN (tokstart + 1, std_regs[c].name, namelen - 1))
1444 yylval.lval = std_regs[c].regnum;
1448 /* Catch specific keywords. Should be done with a data structure. */
1452 if (STREQN (tokstart, "unsigned", 8))
1454 if (current_language->la_language == language_cplus
1455 && STREQN (tokstart, "template", 8))
1457 if (STREQN (tokstart, "volatile", 8))
1458 return VOLATILE_KEYWORD;
1461 if (STREQN (tokstart, "struct", 6))
1463 if (STREQN (tokstart, "signed", 6))
1464 return SIGNED_KEYWORD;
1465 if (STREQN (tokstart, "sizeof", 6))
1469 if (current_language->la_language == language_cplus
1470 && STREQN (tokstart, "class", 5))
1472 if (STREQN (tokstart, "union", 5))
1474 if (STREQN (tokstart, "short", 5))
1476 if (STREQN (tokstart, "const", 5))
1477 return CONST_KEYWORD;
1480 if (STREQN (tokstart, "enum", 4))
1482 if (STREQN (tokstart, "long", 4))
1484 if (current_language->la_language == language_cplus
1485 && STREQN (tokstart, "this", 4))
1487 static const char this_name[] =
1488 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1490 if (lookup_symbol (this_name, expression_context_block,
1491 VAR_NAMESPACE, (int *) NULL,
1492 (struct symtab **) NULL))
1497 if (STREQN (tokstart, "int", 3))
1504 yylval.sval.ptr = tokstart;
1505 yylval.sval.length = namelen;
1507 /* Any other names starting in $ are debugger internal variables. */
1509 if (*tokstart == '$')
1511 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1515 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1516 functions or symtabs. If this is not so, then ...
1517 Use token-type TYPENAME for symbols that happen to be defined
1518 currently as names of types; NAME for other symbols.
1519 The caller is not constrained to care about the distinction. */
1521 char *tmp = copy_name (yylval.sval);
1523 int is_a_field_of_this = 0;
1526 sym = lookup_symbol (tmp, expression_context_block,
1528 current_language->la_language == language_cplus
1529 ? &is_a_field_of_this : (int *) NULL,
1530 (struct symtab **) NULL);
1531 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1532 no psymtabs (coff, xcoff, or some future change to blow away the
1533 psymtabs once once symbols are read). */
1534 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1535 lookup_symtab (tmp))
1537 yylval.ssym.sym = sym;
1538 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1541 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1544 /* Despite the following flaw, we need to keep this code enabled.
1545 Because we can get called from check_stub_method, if we don't
1546 handle nested types then it screws many operations in any
1547 program which uses nested types. */
1548 /* In "A::x", if x is a member function of A and there happens
1549 to be a type (nested or not, since the stabs don't make that
1550 distinction) named x, then this code incorrectly thinks we
1551 are dealing with nested types rather than a member function. */
1555 struct symbol *best_sym;
1557 /* Look ahead to detect nested types. This probably should be
1558 done in the grammar, but trying seemed to introduce a lot
1559 of shift/reduce and reduce/reduce conflicts. It's possible
1560 that it could be done, though. Or perhaps a non-grammar, but
1561 less ad hoc, approach would work well. */
1563 /* Since we do not currently have any way of distinguishing
1564 a nested type from a non-nested one (the stabs don't tell
1565 us whether a type is nested), we just ignore the
1572 /* Skip whitespace. */
1573 while (*p == ' ' || *p == '\t' || *p == '\n')
1575 if (*p == ':' && p[1] == ':')
1577 /* Skip the `::'. */
1579 /* Skip whitespace. */
1580 while (*p == ' ' || *p == '\t' || *p == '\n')
1583 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1584 || (*p >= 'a' && *p <= 'z')
1585 || (*p >= 'A' && *p <= 'Z'))
1589 struct symbol *cur_sym;
1590 /* As big as the whole rest of the expression, which is
1591 at least big enough. */
1592 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1596 memcpy (tmp1, tmp, strlen (tmp));
1597 tmp1 += strlen (tmp);
1598 memcpy (tmp1, "::", 2);
1600 memcpy (tmp1, namestart, p - namestart);
1601 tmp1[p - namestart] = '\0';
1602 cur_sym = lookup_symbol (ncopy, expression_context_block,
1603 VAR_NAMESPACE, (int *) NULL,
1604 (struct symtab **) NULL);
1607 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1625 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1627 yylval.tsym.type = SYMBOL_TYPE (sym);
1631 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1634 /* Input names that aren't symbols but ARE valid hex numbers,
1635 when the input radix permits them, can be names or numbers
1636 depending on the parse. Note we support radixes > 16 here. */
1638 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1639 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1641 YYSTYPE newlval; /* Its value is ignored. */
1642 hextype = parse_number (tokstart, namelen, 0, &newlval);
1645 yylval.ssym.sym = sym;
1646 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1651 /* Any other kind of symbol */
1652 yylval.ssym.sym = sym;
1653 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1662 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);