1 /* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2003, 2004, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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. */
41 #include "gdb_string.h"
43 #include "expression.h"
45 #include "parser-defs.h"
48 #include "bfd.h" /* Required by objfiles.h. */
49 #include "symfile.h" /* Required by objfiles.h. */
50 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
53 #include "cp-support.h"
55 #include "gdb_assert.h"
56 #include "macroscope.h"
58 #define parse_type builtin_type (parse_gdbarch)
60 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
61 as well as gratuitiously global symbol names, so we can have multiple
62 yacc generated parsers in gdb. Note that these are only the variables
63 produced by yacc. If other parser generators (bison, byacc, etc) produce
64 additional global names that conflict at link time, then those parser
65 generators need to be fixed instead of adding those names to this list. */
67 #define yymaxdepth c_maxdepth
68 #define yyparse c_parse_internal
70 #define yyerror c_error
73 #define yydebug c_debug
82 #define yyerrflag c_errflag
83 #define yynerrs c_nerrs
88 #define yystate c_state
94 #define yyreds c_reds /* With YYDEBUG defined */
95 #define yytoks c_toks /* With YYDEBUG defined */
96 #define yyname c_name /* With YYDEBUG defined */
97 #define yyrule c_rule /* With YYDEBUG defined */
100 #define yydefred c_yydefred
101 #define yydgoto c_yydgoto
102 #define yysindex c_yysindex
103 #define yyrindex c_yyrindex
104 #define yygindex c_yygindex
105 #define yytable c_yytable
106 #define yycheck c_yycheck
109 #define YYDEBUG 1 /* Default to yydebug support */
112 #define YYFPRINTF parser_fprintf
116 static int yylex (void);
118 void yyerror (char *);
122 /* Although the yacc "value" of an expression is not used,
123 since the result is stored in the structure being created,
124 other node types do have values. */
140 } typed_val_decfloat;
144 struct typed_stoken tsval;
146 struct symtoken ssym;
149 enum exp_opcode opcode;
150 struct internalvar *ivar;
152 struct stoken_vector svec;
158 /* YYSTYPE gets defined by %union */
159 static int parse_number (char *, int, int, YYSTYPE *);
160 static struct stoken operator_stoken (const char *);
163 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
165 %type <tval> type typebase qualified_type
166 %type <tvec> nonempty_typelist
167 /* %type <bval> block */
169 /* Fancy type parsing. */
170 %type <voidval> func_mod direct_abs_decl abs_decl
172 %type <lval> array_mod
174 %token <typed_val_int> INT
175 %token <typed_val_float> FLOAT
176 %token <typed_val_decfloat> DECFLOAT
178 /* Both NAME and TYPENAME tokens represent symbols in the input,
179 and both convey their data as strings.
180 But a TYPENAME is a string that happens to be defined as a typedef
181 or builtin type name (such as int or char)
182 and a NAME is any other symbol.
183 Contexts where this distinction is not important can use the
184 nonterminal "name", which matches either NAME or TYPENAME. */
186 %token <tsval> STRING
188 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
189 %token <voidval> COMPLETE
190 %token <tsym> TYPENAME
192 %type <svec> string_exp
193 %type <ssym> name_not_typename
194 %type <tsym> typename
196 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
197 but which would parse as a valid number in the current input radix.
198 E.g. "c" when input_radix==16. Depending on the parse, it will be
199 turned into a name or into a number. */
201 %token <ssym> NAME_OR_INT
204 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
208 %type <sval> operator
210 /* Special type cases, put in to allow the parser to distinguish different
212 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
214 %token <voidval> VARIABLE
216 %token <opcode> ASSIGN_MODIFY
225 %right '=' ASSIGN_MODIFY
233 %left '<' '>' LEQ GEQ
238 %right UNARY INCREMENT DECREMENT
239 %right ARROW ARROW_STAR '.' DOT_STAR '[' '('
240 %token <ssym> BLOCKNAME
241 %token <bval> FILENAME
253 { write_exp_elt_opcode(OP_TYPE);
254 write_exp_elt_type($1);
255 write_exp_elt_opcode(OP_TYPE);}
258 /* Expressions, including the comma operator. */
261 { write_exp_elt_opcode (BINOP_COMMA); }
264 /* Expressions, not including the comma operator. */
265 exp : '*' exp %prec UNARY
266 { write_exp_elt_opcode (UNOP_IND); }
269 exp : '&' exp %prec UNARY
270 { write_exp_elt_opcode (UNOP_ADDR); }
273 exp : '-' exp %prec UNARY
274 { write_exp_elt_opcode (UNOP_NEG); }
277 exp : '+' exp %prec UNARY
278 { write_exp_elt_opcode (UNOP_PLUS); }
281 exp : '!' exp %prec UNARY
282 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
285 exp : '~' exp %prec UNARY
286 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
289 exp : INCREMENT exp %prec UNARY
290 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
293 exp : DECREMENT exp %prec UNARY
294 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
297 exp : exp INCREMENT %prec UNARY
298 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
301 exp : exp DECREMENT %prec UNARY
302 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
305 exp : SIZEOF exp %prec UNARY
306 { write_exp_elt_opcode (UNOP_SIZEOF); }
310 { write_exp_elt_opcode (STRUCTOP_PTR);
311 write_exp_string ($3);
312 write_exp_elt_opcode (STRUCTOP_PTR); }
315 exp : exp ARROW name COMPLETE
316 { mark_struct_expression ();
317 write_exp_elt_opcode (STRUCTOP_PTR);
318 write_exp_string ($3);
319 write_exp_elt_opcode (STRUCTOP_PTR); }
322 exp : exp ARROW COMPLETE
324 mark_struct_expression ();
325 write_exp_elt_opcode (STRUCTOP_PTR);
328 write_exp_string (s);
329 write_exp_elt_opcode (STRUCTOP_PTR); }
332 exp : exp ARROW qualified_name
333 { /* exp->type::name becomes exp->*(&type::name) */
334 /* Note: this doesn't work if name is a
335 static member! FIXME */
336 write_exp_elt_opcode (UNOP_ADDR);
337 write_exp_elt_opcode (STRUCTOP_MPTR); }
340 exp : exp ARROW_STAR exp
341 { write_exp_elt_opcode (STRUCTOP_MPTR); }
345 { write_exp_elt_opcode (STRUCTOP_STRUCT);
346 write_exp_string ($3);
347 write_exp_elt_opcode (STRUCTOP_STRUCT); }
350 exp : exp '.' name COMPLETE
351 { mark_struct_expression ();
352 write_exp_elt_opcode (STRUCTOP_STRUCT);
353 write_exp_string ($3);
354 write_exp_elt_opcode (STRUCTOP_STRUCT); }
357 exp : exp '.' COMPLETE
359 mark_struct_expression ();
360 write_exp_elt_opcode (STRUCTOP_STRUCT);
363 write_exp_string (s);
364 write_exp_elt_opcode (STRUCTOP_STRUCT); }
367 exp : exp '.' qualified_name
368 { /* exp.type::name becomes exp.*(&type::name) */
369 /* Note: this doesn't work if name is a
370 static member! FIXME */
371 write_exp_elt_opcode (UNOP_ADDR);
372 write_exp_elt_opcode (STRUCTOP_MEMBER); }
375 exp : exp DOT_STAR exp
376 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
379 exp : exp '[' exp1 ']'
380 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
384 /* This is to save the value of arglist_len
385 being accumulated by an outer function call. */
386 { start_arglist (); }
387 arglist ')' %prec ARROW
388 { write_exp_elt_opcode (OP_FUNCALL);
389 write_exp_elt_longcst ((LONGEST) end_arglist ());
390 write_exp_elt_opcode (OP_FUNCALL); }
394 { start_arglist (); }
404 arglist : arglist ',' exp %prec ABOVE_COMMA
408 exp : exp '(' nonempty_typelist ')' const_or_volatile
410 write_exp_elt_opcode (TYPE_INSTANCE);
411 write_exp_elt_longcst ((LONGEST) $<ivec>3[0]);
412 for (i = 0; i < $<ivec>3[0]; ++i)
413 write_exp_elt_type ($<tvec>3[i + 1]);
414 write_exp_elt_longcst((LONGEST) $<ivec>3[0]);
415 write_exp_elt_opcode (TYPE_INSTANCE);
421 { $$ = end_arglist () - 1; }
423 exp : lcurly arglist rcurly %prec ARROW
424 { write_exp_elt_opcode (OP_ARRAY);
425 write_exp_elt_longcst ((LONGEST) 0);
426 write_exp_elt_longcst ((LONGEST) $3);
427 write_exp_elt_opcode (OP_ARRAY); }
430 exp : lcurly type rcurly exp %prec UNARY
431 { write_exp_elt_opcode (UNOP_MEMVAL);
432 write_exp_elt_type ($2);
433 write_exp_elt_opcode (UNOP_MEMVAL); }
436 exp : '(' type ')' exp %prec UNARY
437 { write_exp_elt_opcode (UNOP_CAST);
438 write_exp_elt_type ($2);
439 write_exp_elt_opcode (UNOP_CAST); }
446 /* Binary operators in order of decreasing precedence. */
449 { write_exp_elt_opcode (BINOP_REPEAT); }
453 { write_exp_elt_opcode (BINOP_MUL); }
457 { write_exp_elt_opcode (BINOP_DIV); }
461 { write_exp_elt_opcode (BINOP_REM); }
465 { write_exp_elt_opcode (BINOP_ADD); }
469 { write_exp_elt_opcode (BINOP_SUB); }
473 { write_exp_elt_opcode (BINOP_LSH); }
477 { write_exp_elt_opcode (BINOP_RSH); }
481 { write_exp_elt_opcode (BINOP_EQUAL); }
484 exp : exp NOTEQUAL exp
485 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
489 { write_exp_elt_opcode (BINOP_LEQ); }
493 { write_exp_elt_opcode (BINOP_GEQ); }
497 { write_exp_elt_opcode (BINOP_LESS); }
501 { write_exp_elt_opcode (BINOP_GTR); }
505 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
509 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
513 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
517 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
521 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
524 exp : exp '?' exp ':' exp %prec '?'
525 { write_exp_elt_opcode (TERNOP_COND); }
529 { write_exp_elt_opcode (BINOP_ASSIGN); }
532 exp : exp ASSIGN_MODIFY exp
533 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
534 write_exp_elt_opcode ($2);
535 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
539 { write_exp_elt_opcode (OP_LONG);
540 write_exp_elt_type ($1.type);
541 write_exp_elt_longcst ((LONGEST)($1.val));
542 write_exp_elt_opcode (OP_LONG); }
547 struct stoken_vector vec;
550 write_exp_string_vector ($1.type, &vec);
556 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
557 write_exp_elt_opcode (OP_LONG);
558 write_exp_elt_type (val.typed_val_int.type);
559 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
560 write_exp_elt_opcode (OP_LONG);
566 { write_exp_elt_opcode (OP_DOUBLE);
567 write_exp_elt_type ($1.type);
568 write_exp_elt_dblcst ($1.dval);
569 write_exp_elt_opcode (OP_DOUBLE); }
573 { write_exp_elt_opcode (OP_DECFLOAT);
574 write_exp_elt_type ($1.type);
575 write_exp_elt_decfloatcst ($1.val);
576 write_exp_elt_opcode (OP_DECFLOAT); }
583 /* Already written by write_dollar_variable. */
586 exp : SIZEOF '(' type ')' %prec UNARY
587 { write_exp_elt_opcode (OP_LONG);
588 write_exp_elt_type (parse_type->builtin_int);
590 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
591 write_exp_elt_opcode (OP_LONG); }
597 /* We copy the string here, and not in the
598 lexer, to guarantee that we do not leak a
599 string. Note that we follow the
600 NUL-termination convention of the
602 struct typed_stoken *vec = XNEW (struct typed_stoken);
607 vec->length = $1.length;
608 vec->ptr = malloc ($1.length + 1);
609 memcpy (vec->ptr, $1.ptr, $1.length + 1);
614 /* Note that we NUL-terminate here, but just
618 $$.tokens = realloc ($$.tokens,
619 $$.len * sizeof (struct typed_stoken));
621 p = malloc ($2.length + 1);
622 memcpy (p, $2.ptr, $2.length + 1);
624 $$.tokens[$$.len - 1].type = $2.type;
625 $$.tokens[$$.len - 1].length = $2.length;
626 $$.tokens[$$.len - 1].ptr = p;
633 enum c_string_type type = C_STRING;
635 for (i = 0; i < $1.len; ++i)
637 switch ($1.tokens[i].type)
645 && type != $1.tokens[i].type)
646 error ("Undefined string concatenation.");
647 type = $1.tokens[i].type;
651 internal_error (__FILE__, __LINE__,
652 "unrecognized type in string concatenation");
656 write_exp_string_vector (type, &$1);
657 for (i = 0; i < $1.len; ++i)
658 free ($1.tokens[i].ptr);
665 { write_exp_elt_opcode (OP_LONG);
666 write_exp_elt_type (parse_type->builtin_bool);
667 write_exp_elt_longcst ((LONGEST) 1);
668 write_exp_elt_opcode (OP_LONG); }
672 { write_exp_elt_opcode (OP_LONG);
673 write_exp_elt_type (parse_type->builtin_bool);
674 write_exp_elt_longcst ((LONGEST) 0);
675 write_exp_elt_opcode (OP_LONG); }
683 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
685 error ("No file or function \"%s\".",
686 copy_name ($1.stoken));
694 block : block COLONCOLON name
696 = lookup_symbol (copy_name ($3), $1,
697 VAR_DOMAIN, (int *) NULL);
698 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
699 error ("No function \"%s\" in specified context.",
701 $$ = SYMBOL_BLOCK_VALUE (tem); }
704 variable: block COLONCOLON name
705 { struct symbol *sym;
706 sym = lookup_symbol (copy_name ($3), $1,
707 VAR_DOMAIN, (int *) NULL);
709 error ("No symbol \"%s\" in specified context.",
712 write_exp_elt_opcode (OP_VAR_VALUE);
713 /* block_found is set by lookup_symbol. */
714 write_exp_elt_block (block_found);
715 write_exp_elt_sym (sym);
716 write_exp_elt_opcode (OP_VAR_VALUE); }
719 qualified_name: typebase COLONCOLON name
721 struct type *type = $1;
722 CHECK_TYPEDEF (type);
723 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
724 && TYPE_CODE (type) != TYPE_CODE_UNION
725 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
726 error ("`%s' is not defined as an aggregate type.",
729 write_exp_elt_opcode (OP_SCOPE);
730 write_exp_elt_type (type);
731 write_exp_string ($3);
732 write_exp_elt_opcode (OP_SCOPE);
734 | typebase COLONCOLON '~' name
736 struct type *type = $1;
737 struct stoken tmp_token;
738 CHECK_TYPEDEF (type);
739 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
740 && TYPE_CODE (type) != TYPE_CODE_UNION
741 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
742 error ("`%s' is not defined as an aggregate type.",
745 tmp_token.ptr = (char*) alloca ($4.length + 2);
746 tmp_token.length = $4.length + 1;
747 tmp_token.ptr[0] = '~';
748 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
749 tmp_token.ptr[tmp_token.length] = 0;
751 /* Check for valid destructor name. */
752 destructor_name_p (tmp_token.ptr, type);
753 write_exp_elt_opcode (OP_SCOPE);
754 write_exp_elt_type (type);
755 write_exp_string (tmp_token);
756 write_exp_elt_opcode (OP_SCOPE);
760 variable: qualified_name
763 char *name = copy_name ($2);
765 struct minimal_symbol *msymbol;
768 lookup_symbol (name, (const struct block *) NULL,
769 VAR_DOMAIN, (int *) NULL);
772 write_exp_elt_opcode (OP_VAR_VALUE);
773 write_exp_elt_block (NULL);
774 write_exp_elt_sym (sym);
775 write_exp_elt_opcode (OP_VAR_VALUE);
779 msymbol = lookup_minimal_symbol (name, NULL, NULL);
781 write_exp_msymbol (msymbol);
782 else if (!have_full_symbols () && !have_partial_symbols ())
783 error ("No symbol table is loaded. Use the \"file\" command.");
785 error ("No symbol \"%s\" in current context.", name);
789 variable: name_not_typename
790 { struct symbol *sym = $1.sym;
794 if (symbol_read_needs_frame (sym))
796 if (innermost_block == 0
797 || contained_in (block_found,
799 innermost_block = block_found;
802 write_exp_elt_opcode (OP_VAR_VALUE);
803 /* We want to use the selected frame, not
804 another more inner frame which happens to
805 be in the same block. */
806 write_exp_elt_block (NULL);
807 write_exp_elt_sym (sym);
808 write_exp_elt_opcode (OP_VAR_VALUE);
810 else if ($1.is_a_field_of_this)
812 /* C++: it hangs off of `this'. Must
813 not inadvertently convert from a method call
815 if (innermost_block == 0
816 || contained_in (block_found,
818 innermost_block = block_found;
819 write_exp_elt_opcode (OP_THIS);
820 write_exp_elt_opcode (OP_THIS);
821 write_exp_elt_opcode (STRUCTOP_PTR);
822 write_exp_string ($1.stoken);
823 write_exp_elt_opcode (STRUCTOP_PTR);
827 struct minimal_symbol *msymbol;
828 char *arg = copy_name ($1.stoken);
831 lookup_minimal_symbol (arg, NULL, NULL);
833 write_exp_msymbol (msymbol);
834 else if (!have_full_symbols () && !have_partial_symbols ())
835 error ("No symbol table is loaded. Use the \"file\" command.");
837 error ("No symbol \"%s\" in current context.",
838 copy_name ($1.stoken));
843 space_identifier : '@' NAME
844 { push_type_address_space (copy_name ($2.stoken));
845 push_type (tp_space_identifier);
849 const_or_volatile: const_or_volatile_noopt
853 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
856 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
857 | const_or_volatile_noopt
860 const_or_volatile_or_space_identifier:
861 const_or_volatile_or_space_identifier_noopt
866 { push_type (tp_pointer); $$ = 0; }
868 { push_type (tp_pointer); $$ = $2; }
870 { push_type (tp_reference); $$ = 0; }
872 { push_type (tp_reference); $$ = $2; }
876 direct_abs_decl: '(' abs_decl ')'
878 | direct_abs_decl array_mod
881 push_type (tp_array);
886 push_type (tp_array);
890 | direct_abs_decl func_mod
891 { push_type (tp_function); }
893 { push_type (tp_function); }
904 | '(' nonempty_typelist ')'
905 { free ($2); $$ = 0; }
908 /* We used to try to recognize pointer to member types here, but
909 that didn't work (shift/reduce conflicts meant that these rules never
910 got executed). The problem is that
911 int (foo::bar::baz::bizzle)
912 is a function type but
913 int (foo::bar::baz::bizzle::*)
914 is a pointer to member type. Stroustrup loses again! */
919 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
923 { $$ = parse_type->builtin_int; }
925 { $$ = parse_type->builtin_long; }
927 { $$ = parse_type->builtin_short; }
929 { $$ = parse_type->builtin_long; }
930 | LONG SIGNED_KEYWORD INT_KEYWORD
931 { $$ = parse_type->builtin_long; }
932 | LONG SIGNED_KEYWORD
933 { $$ = parse_type->builtin_long; }
934 | SIGNED_KEYWORD LONG INT_KEYWORD
935 { $$ = parse_type->builtin_long; }
936 | UNSIGNED LONG INT_KEYWORD
937 { $$ = parse_type->builtin_unsigned_long; }
938 | LONG UNSIGNED INT_KEYWORD
939 { $$ = parse_type->builtin_unsigned_long; }
941 { $$ = parse_type->builtin_unsigned_long; }
943 { $$ = parse_type->builtin_long_long; }
944 | LONG LONG INT_KEYWORD
945 { $$ = parse_type->builtin_long_long; }
946 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
947 { $$ = parse_type->builtin_long_long; }
948 | LONG LONG SIGNED_KEYWORD
949 { $$ = parse_type->builtin_long_long; }
950 | SIGNED_KEYWORD LONG LONG
951 { $$ = parse_type->builtin_long_long; }
952 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
953 { $$ = parse_type->builtin_long_long; }
955 { $$ = parse_type->builtin_unsigned_long_long; }
956 | UNSIGNED LONG LONG INT_KEYWORD
957 { $$ = parse_type->builtin_unsigned_long_long; }
959 { $$ = parse_type->builtin_unsigned_long_long; }
960 | LONG LONG UNSIGNED INT_KEYWORD
961 { $$ = parse_type->builtin_unsigned_long_long; }
963 { $$ = parse_type->builtin_short; }
964 | SHORT SIGNED_KEYWORD INT_KEYWORD
965 { $$ = parse_type->builtin_short; }
966 | SHORT SIGNED_KEYWORD
967 { $$ = parse_type->builtin_short; }
968 | UNSIGNED SHORT INT_KEYWORD
969 { $$ = parse_type->builtin_unsigned_short; }
971 { $$ = parse_type->builtin_unsigned_short; }
972 | SHORT UNSIGNED INT_KEYWORD
973 { $$ = parse_type->builtin_unsigned_short; }
975 { $$ = parse_type->builtin_double; }
976 | LONG DOUBLE_KEYWORD
977 { $$ = parse_type->builtin_long_double; }
979 { $$ = lookup_struct (copy_name ($2),
980 expression_context_block); }
982 { $$ = lookup_struct (copy_name ($2),
983 expression_context_block); }
985 { $$ = lookup_union (copy_name ($2),
986 expression_context_block); }
988 { $$ = lookup_enum (copy_name ($2),
989 expression_context_block); }
991 { $$ = lookup_unsigned_typename (parse_language,
993 TYPE_NAME($2.type)); }
995 { $$ = parse_type->builtin_unsigned_int; }
996 | SIGNED_KEYWORD typename
997 { $$ = lookup_signed_typename (parse_language,
999 TYPE_NAME($2.type)); }
1001 { $$ = parse_type->builtin_int; }
1002 /* It appears that this rule for templates is never
1003 reduced; template recognition happens by lookahead
1004 in the token processing code in yylex. */
1005 | TEMPLATE name '<' type '>'
1006 { $$ = lookup_template_type(copy_name($2), $4,
1007 expression_context_block);
1009 | const_or_volatile_or_space_identifier_noopt typebase
1010 { $$ = follow_types ($2); }
1011 | typebase const_or_volatile_or_space_identifier_noopt
1012 { $$ = follow_types ($1); }
1016 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
1017 reduce-reduce conflicts, because the parser doesn't know whether or
1018 not to use qualified_name or qualified_type: the rules are
1019 identical. If the parser is parsing 'A::B::x', then, when it sees
1020 the second '::', it knows that the expression to the left of it has
1021 to be a type, so it uses qualified_type. But if it is parsing just
1022 'A::B', then it doesn't have any way of knowing which rule to use,
1023 so there's a reduce-reduce conflict; it picks qualified_name, since
1024 that occurs earlier in this file than qualified_type.
1026 There's no good way to fix this with the grammar as it stands; as
1027 far as I can tell, some of the problems arise from ambiguities that
1028 GDB introduces ('start' can be either an expression or a type), but
1029 some of it is inherent to the nature of C++ (you want to treat the
1030 input "(FOO)" fairly differently depending on whether FOO is an
1031 expression or a type, and if FOO is a complex expression, this can
1032 be hard to determine at the right time). Fortunately, it works
1033 pretty well in most cases. For example, if you do 'ptype A::B',
1034 where A::B is a nested type, then the parser will mistakenly
1035 misidentify it as an expression; but evaluate_subexp will get
1036 called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
1037 will work out anyways. But there are situations where the parser
1038 will get confused: the most common one that I've run into is when
1041 print *((A::B *) x)"
1043 where the parser doesn't realize that A::B has to be a type until
1044 it hits the first right paren, at which point it's too late. (The
1045 workaround is to type "print *(('A::B' *) x)" instead.) (And
1046 another solution is to fix our symbol-handling code so that the
1047 user never wants to type something like that in the first place,
1048 because we get all the types right without the user's help!)
1050 Perhaps we could fix this by making the lexer smarter. Some of
1051 this functionality used to be in the lexer, but in a way that
1052 worked even less well than the current solution: that attempt
1053 involved having the parser sometimes handle '::' and having the
1054 lexer sometimes handle it, and without a clear division of
1055 responsibility, it quickly degenerated into a big mess. Probably
1056 the eventual correct solution will give more of a role to the lexer
1057 (ideally via code that is shared between the lexer and
1058 decode_line_1), but I'm not holding my breath waiting for somebody
1059 to get around to cleaning this up... */
1061 qualified_type: typebase COLONCOLON name
1063 struct type *type = $1;
1064 struct type *new_type;
1065 char *ncopy = alloca ($3.length + 1);
1067 memcpy (ncopy, $3.ptr, $3.length);
1068 ncopy[$3.length] = '\0';
1070 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1071 && TYPE_CODE (type) != TYPE_CODE_UNION
1072 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
1073 error ("`%s' is not defined as an aggregate type.",
1076 new_type = cp_lookup_nested_type (type, ncopy,
1077 expression_context_block);
1078 if (new_type == NULL)
1079 error ("No type \"%s\" within class or namespace \"%s\".",
1080 ncopy, TYPE_NAME (type));
1089 $$.stoken.ptr = "int";
1090 $$.stoken.length = 3;
1091 $$.type = parse_type->builtin_int;
1095 $$.stoken.ptr = "long";
1096 $$.stoken.length = 4;
1097 $$.type = parse_type->builtin_long;
1101 $$.stoken.ptr = "short";
1102 $$.stoken.length = 5;
1103 $$.type = parse_type->builtin_short;
1109 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1110 $<ivec>$[0] = 1; /* Number of types in vector */
1113 | nonempty_typelist ',' type
1114 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1115 $$ = (struct type **) realloc ((char *) $1, len);
1116 $$[$<ivec>$[0]] = $3;
1121 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1122 { $$ = follow_types ($1); }
1125 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1126 | VOLATILE_KEYWORD CONST_KEYWORD
1129 const_or_volatile_noopt: const_and_volatile
1130 { push_type (tp_const);
1131 push_type (tp_volatile);
1134 { push_type (tp_const); }
1136 { push_type (tp_volatile); }
1139 operator: OPERATOR NEW
1140 { $$ = operator_stoken (" new"); }
1142 { $$ = operator_stoken (" delete"); }
1143 | OPERATOR NEW '[' ']'
1144 { $$ = operator_stoken (" new[]"); }
1145 | OPERATOR DELETE '[' ']'
1146 { $$ = operator_stoken (" delete[]"); }
1148 { $$ = operator_stoken ("+"); }
1150 { $$ = operator_stoken ("-"); }
1152 { $$ = operator_stoken ("*"); }
1154 { $$ = operator_stoken ("/"); }
1156 { $$ = operator_stoken ("%"); }
1158 { $$ = operator_stoken ("^"); }
1160 { $$ = operator_stoken ("&"); }
1162 { $$ = operator_stoken ("|"); }
1164 { $$ = operator_stoken ("~"); }
1166 { $$ = operator_stoken ("!"); }
1168 { $$ = operator_stoken ("="); }
1170 { $$ = operator_stoken ("<"); }
1172 { $$ = operator_stoken (">"); }
1173 | OPERATOR ASSIGN_MODIFY
1174 { const char *op = "unknown";
1198 case BINOP_BITWISE_IOR:
1201 case BINOP_BITWISE_AND:
1204 case BINOP_BITWISE_XOR:
1211 $$ = operator_stoken (op);
1214 { $$ = operator_stoken ("<<"); }
1216 { $$ = operator_stoken (">>"); }
1218 { $$ = operator_stoken ("=="); }
1220 { $$ = operator_stoken ("!="); }
1222 { $$ = operator_stoken ("<="); }
1224 { $$ = operator_stoken (">="); }
1226 { $$ = operator_stoken ("&&"); }
1228 { $$ = operator_stoken ("||"); }
1229 | OPERATOR INCREMENT
1230 { $$ = operator_stoken ("++"); }
1231 | OPERATOR DECREMENT
1232 { $$ = operator_stoken ("--"); }
1234 { $$ = operator_stoken (","); }
1235 | OPERATOR ARROW_STAR
1236 { $$ = operator_stoken ("->*"); }
1238 { $$ = operator_stoken ("->"); }
1240 { $$ = operator_stoken ("()"); }
1242 { $$ = operator_stoken ("[]"); }
1246 struct ui_file *buf = mem_fileopen ();
1248 c_print_type ($2, NULL, buf, -1, 0);
1249 name = ui_file_xstrdup (buf, &length);
1250 ui_file_delete (buf);
1251 $$ = operator_stoken (name);
1258 name : NAME { $$ = $1.stoken; }
1259 | BLOCKNAME { $$ = $1.stoken; }
1260 | TYPENAME { $$ = $1.stoken; }
1261 | NAME_OR_INT { $$ = $1.stoken; }
1262 | operator { $$ = $1; }
1265 name_not_typename : NAME
1267 /* These would be useful if name_not_typename was useful, but it is just
1268 a fake for "variable", so these cause reduce/reduce conflicts because
1269 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1270 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1271 context where only a name could occur, this might be useful.
1278 /* Returns a stoken of the operator name given by OP (which does not
1279 include the string "operator"). */
1280 static struct stoken
1281 operator_stoken (const char *op)
1283 static const char *operator_string = "operator";
1284 struct stoken st = { NULL, 0 };
1285 st.length = strlen (operator_string) + strlen (op);
1286 st.ptr = malloc (st.length + 1);
1287 strcpy (st.ptr, operator_string);
1288 strcat (st.ptr, op);
1290 /* The toplevel (c_parse) will free the memory allocated here. */
1291 make_cleanup (free, st.ptr);
1295 /* Take care of parsing a number (anything that starts with a digit).
1296 Set yylval and return the token type; update lexptr.
1297 LEN is the number of characters in it. */
1299 /*** Needs some error checking for the float case ***/
1302 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1304 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1305 here, and we do kind of silly things like cast to unsigned. */
1312 int base = input_radix;
1315 /* Number of "L" suffixes encountered. */
1318 /* We have found a "L" or "U" suffix. */
1319 int found_suffix = 0;
1322 struct type *signed_type;
1323 struct type *unsigned_type;
1327 /* It's a float since it contains a point or an exponent. */
1329 int num; /* number of tokens scanned by scanf */
1332 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1333 point. Return DECFLOAT. */
1335 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1338 putithere->typed_val_decfloat.type
1339 = parse_type->builtin_decfloat;
1340 decimal_from_string (putithere->typed_val_decfloat.val, 4,
1341 gdbarch_byte_order (parse_gdbarch), p);
1346 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1349 putithere->typed_val_decfloat.type
1350 = parse_type->builtin_decdouble;
1351 decimal_from_string (putithere->typed_val_decfloat.val, 8,
1352 gdbarch_byte_order (parse_gdbarch), p);
1357 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1360 putithere->typed_val_decfloat.type
1361 = parse_type->builtin_declong;
1362 decimal_from_string (putithere->typed_val_decfloat.val, 16,
1363 gdbarch_byte_order (parse_gdbarch), p);
1369 saved_char = p[len];
1370 p[len] = 0; /* null-terminate the token */
1371 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
1372 &putithere->typed_val_float.dval, s);
1373 p[len] = saved_char; /* restore the input stream */
1376 putithere->typed_val_float.type =
1377 parse_type->builtin_double;
1381 /* See if it has any float suffix: 'f' for float, 'l' for long
1383 if (!strcasecmp (s, "f"))
1384 putithere->typed_val_float.type =
1385 parse_type->builtin_float;
1386 else if (!strcasecmp (s, "l"))
1387 putithere->typed_val_float.type =
1388 parse_type->builtin_long_double;
1400 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1434 if (c >= 'A' && c <= 'Z')
1436 if (c != 'l' && c != 'u')
1438 if (c >= '0' && c <= '9')
1446 if (base > 10 && c >= 'a' && c <= 'f')
1450 n += i = c - 'a' + 10;
1463 return ERROR; /* Char not a digit */
1466 return ERROR; /* Invalid digit in this base */
1468 /* Portably test for overflow (only works for nonzero values, so make
1469 a second check for zero). FIXME: Can't we just make n and prevn
1470 unsigned and avoid this? */
1471 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1472 unsigned_p = 1; /* Try something unsigned */
1474 /* Portably test for unsigned overflow.
1475 FIXME: This check is wrong; for example it doesn't find overflow
1476 on 0x123456789 when LONGEST is 32 bits. */
1477 if (c != 'l' && c != 'u' && n != 0)
1479 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1480 error ("Numeric constant too large.");
1485 /* An integer constant is an int, a long, or a long long. An L
1486 suffix forces it to be long; an LL suffix forces it to be long
1487 long. If not forced to a larger size, it gets the first type of
1488 the above that it fits in. To figure out whether it fits, we
1489 shift it right and see whether anything remains. Note that we
1490 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1491 operation, because many compilers will warn about such a shift
1492 (which always produces a zero result). Sometimes gdbarch_int_bit
1493 or gdbarch_long_bit will be that big, sometimes not. To deal with
1494 the case where it is we just always shift the value more than
1495 once, with fewer bits each time. */
1497 un = (ULONGEST)n >> 2;
1499 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1501 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1503 /* A large decimal (not hex or octal) constant (between INT_MAX
1504 and UINT_MAX) is a long or unsigned long, according to ANSI,
1505 never an unsigned int, but this code treats it as unsigned
1506 int. This probably should be fixed. GCC gives a warning on
1509 unsigned_type = parse_type->builtin_unsigned_int;
1510 signed_type = parse_type->builtin_int;
1512 else if (long_p <= 1
1513 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1515 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1516 unsigned_type = parse_type->builtin_unsigned_long;
1517 signed_type = parse_type->builtin_long;
1522 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1523 < gdbarch_long_long_bit (parse_gdbarch))
1524 /* A long long does not fit in a LONGEST. */
1525 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1527 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1528 high_bit = (ULONGEST) 1 << shift;
1529 unsigned_type = parse_type->builtin_unsigned_long_long;
1530 signed_type = parse_type->builtin_long_long;
1533 putithere->typed_val_int.val = n;
1535 /* If the high bit of the worked out type is set then this number
1536 has to be unsigned. */
1538 if (unsigned_p || (n & high_bit))
1540 putithere->typed_val_int.type = unsigned_type;
1544 putithere->typed_val_int.type = signed_type;
1550 /* Temporary obstack used for holding strings. */
1551 static struct obstack tempbuf;
1552 static int tempbuf_init;
1554 /* Parse a C escape sequence. The initial backslash of the sequence
1555 is at (*PTR)[-1]. *PTR will be updated to point to just after the
1556 last character of the sequence. If OUTPUT is not NULL, the
1557 translated form of the escape sequence will be written there. If
1558 OUTPUT is NULL, no output is written and the call will only affect
1559 *PTR. If an escape sequence is expressed in target bytes, then the
1560 entire sequence will simply be copied to OUTPUT. Return 1 if any
1561 character was emitted, 0 otherwise. */
1564 c_parse_escape (char **ptr, struct obstack *output)
1566 char *tokptr = *ptr;
1569 /* Some escape sequences undergo character set conversion. Those we
1573 /* Hex escapes do not undergo character set conversion, so keep
1574 the escape sequence for later. */
1577 obstack_grow_str (output, "\\x");
1579 if (!isxdigit (*tokptr))
1580 error (_("\\x escape without a following hex digit"));
1581 while (isxdigit (*tokptr))
1584 obstack_1grow (output, *tokptr);
1589 /* Octal escapes do not undergo character set conversion, so
1590 keep the escape sequence for later. */
1602 obstack_grow_str (output, "\\");
1604 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1608 obstack_1grow (output, *tokptr);
1614 /* We handle UCNs later. We could handle them here, but that
1615 would mean a spurious error in the case where the UCN could
1616 be converted to the target charset but not the host
1622 int i, len = c == 'U' ? 8 : 4;
1625 obstack_1grow (output, '\\');
1626 obstack_1grow (output, *tokptr);
1629 if (!isxdigit (*tokptr))
1630 error (_("\\%c escape without a following hex digit"), c);
1631 for (i = 0; i < len && isxdigit (*tokptr); ++i)
1634 obstack_1grow (output, *tokptr);
1640 /* We must pass backslash through so that it does not
1641 cause quoting during the second expansion. */
1644 obstack_grow_str (output, "\\\\");
1648 /* Escapes which undergo conversion. */
1651 obstack_1grow (output, '\a');
1656 obstack_1grow (output, '\b');
1661 obstack_1grow (output, '\f');
1666 obstack_1grow (output, '\n');
1671 obstack_1grow (output, '\r');
1676 obstack_1grow (output, '\t');
1681 obstack_1grow (output, '\v');
1685 /* GCC extension. */
1688 obstack_1grow (output, HOST_ESCAPE_CHAR);
1692 /* Backslash-newline expands to nothing at all. */
1698 /* A few escapes just expand to the character itself. */
1702 /* GCC extensions. */
1707 /* Unrecognized escapes turn into the character itself. */
1710 obstack_1grow (output, *tokptr);
1718 /* Parse a string or character literal from TOKPTR. The string or
1719 character may be wide or unicode. *OUTPTR is set to just after the
1720 end of the literal in the input string. The resulting token is
1721 stored in VALUE. This returns a token value, either STRING or
1722 CHAR, depending on what was parsed. *HOST_CHARS is set to the
1723 number of host characters in the literal. */
1725 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
1729 enum c_string_type type;
1731 /* Build the gdb internal form of the input string in tempbuf. Note
1732 that the buffer is null byte terminated *only* for the
1733 convenience of debugging gdb itself and printing the buffer
1734 contents when the buffer contains no embedded nulls. Gdb does
1735 not depend upon the buffer being null byte terminated, it uses
1736 the length string instead. This allows gdb to handle C strings
1737 (as well as strings in other languages) with embedded null
1743 obstack_free (&tempbuf, NULL);
1744 obstack_init (&tempbuf);
1746 /* Record the string type. */
1749 type = C_WIDE_STRING;
1752 else if (*tokptr == 'u')
1757 else if (*tokptr == 'U')
1765 /* Skip the quote. */
1779 *host_chars += c_parse_escape (&tokptr, &tempbuf);
1781 else if (c == quote)
1785 obstack_1grow (&tempbuf, c);
1787 /* FIXME: this does the wrong thing with multi-byte host
1788 characters. We could use mbrlen here, but that would
1789 make "set host-charset" a bit less useful. */
1794 if (*tokptr != quote)
1797 error ("Unterminated string in expression.");
1799 error ("Unmatched single quote.");
1804 value->ptr = obstack_base (&tempbuf);
1805 value->length = obstack_object_size (&tempbuf);
1809 return quote == '"' ? STRING : CHAR;
1816 enum exp_opcode opcode;
1820 static const struct token tokentab3[] =
1822 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
1823 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
1824 {"->*", ARROW_STAR, BINOP_END, 1}
1827 static const struct token tokentab2[] =
1829 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
1830 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
1831 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
1832 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
1833 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
1834 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
1835 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
1836 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
1837 {"++", INCREMENT, BINOP_END, 0},
1838 {"--", DECREMENT, BINOP_END, 0},
1839 {"->", ARROW, BINOP_END, 0},
1840 {"&&", ANDAND, BINOP_END, 0},
1841 {"||", OROR, BINOP_END, 0},
1842 /* "::" is *not* only C++: gdb overrides its meaning in several
1843 different ways, e.g., 'filename'::func, function::variable. */
1844 {"::", COLONCOLON, BINOP_END, 0},
1845 {"<<", LSH, BINOP_END, 0},
1846 {">>", RSH, BINOP_END, 0},
1847 {"==", EQUAL, BINOP_END, 0},
1848 {"!=", NOTEQUAL, BINOP_END, 0},
1849 {"<=", LEQ, BINOP_END, 0},
1850 {">=", GEQ, BINOP_END, 0},
1851 {".*", DOT_STAR, BINOP_END, 1}
1854 /* Identifier-like tokens. */
1855 static const struct token ident_tokens[] =
1857 {"unsigned", UNSIGNED, OP_NULL, 0},
1858 {"template", TEMPLATE, OP_NULL, 1},
1859 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
1860 {"struct", STRUCT, OP_NULL, 0},
1861 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
1862 {"sizeof", SIZEOF, OP_NULL, 0},
1863 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
1864 {"false", FALSEKEYWORD, OP_NULL, 1},
1865 {"class", CLASS, OP_NULL, 1},
1866 {"union", UNION, OP_NULL, 0},
1867 {"short", SHORT, OP_NULL, 0},
1868 {"const", CONST_KEYWORD, OP_NULL, 0},
1869 {"enum", ENUM, OP_NULL, 0},
1870 {"long", LONG, OP_NULL, 0},
1871 {"true", TRUEKEYWORD, OP_NULL, 1},
1872 {"int", INT_KEYWORD, OP_NULL, 0},
1873 {"new", NEW, OP_NULL, 1},
1874 {"delete", DELETE, OP_NULL, 1},
1875 {"operator", OPERATOR, OP_NULL, 1},
1877 {"and", ANDAND, BINOP_END, 1},
1878 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, 1},
1879 {"bitand", '&', OP_NULL, 1},
1880 {"bitor", '|', OP_NULL, 1},
1881 {"compl", '~', OP_NULL, 1},
1882 {"not", '!', OP_NULL, 1},
1883 {"not_eq", NOTEQUAL, BINOP_END, 1},
1884 {"or", OROR, BINOP_END, 1},
1885 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 1},
1886 {"xor", '^', OP_NULL, 1},
1887 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 1}
1890 /* When we find that lexptr (the global var defined in parse.c) is
1891 pointing at a macro invocation, we expand the invocation, and call
1892 scan_macro_expansion to save the old lexptr here and point lexptr
1893 into the expanded text. When we reach the end of that, we call
1894 end_macro_expansion to pop back to the value we saved here. The
1895 macro expansion code promises to return only fully-expanded text,
1896 so we don't need to "push" more than one level.
1898 This is disgusting, of course. It would be cleaner to do all macro
1899 expansion beforehand, and then hand that to lexptr. But we don't
1900 really know where the expression ends. Remember, in a command like
1902 (gdb) break *ADDRESS if CONDITION
1904 we evaluate ADDRESS in the scope of the current frame, but we
1905 evaluate CONDITION in the scope of the breakpoint's location. So
1906 it's simply wrong to try to macro-expand the whole thing at once. */
1907 static char *macro_original_text;
1909 /* We save all intermediate macro expansions on this obstack for the
1910 duration of a single parse. The expansion text may sometimes have
1911 to live past the end of the expansion, due to yacc lookahead.
1912 Rather than try to be clever about saving the data for a single
1913 token, we simply keep it all and delete it after parsing has
1915 static struct obstack expansion_obstack;
1918 scan_macro_expansion (char *expansion)
1922 /* We'd better not be trying to push the stack twice. */
1923 gdb_assert (! macro_original_text);
1925 /* Copy to the obstack, and then free the intermediate
1927 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
1930 /* Save the old lexptr value, so we can return to it when we're done
1931 parsing the expanded text. */
1932 macro_original_text = lexptr;
1938 scanning_macro_expansion (void)
1940 return macro_original_text != 0;
1945 finished_macro_expansion (void)
1947 /* There'd better be something to pop back to. */
1948 gdb_assert (macro_original_text);
1950 /* Pop back to the original text. */
1951 lexptr = macro_original_text;
1952 macro_original_text = 0;
1957 scan_macro_cleanup (void *dummy)
1959 if (macro_original_text)
1960 finished_macro_expansion ();
1962 obstack_free (&expansion_obstack, NULL);
1966 /* The scope used for macro expansion. */
1967 static struct macro_scope *expression_macro_scope;
1969 /* This is set if a NAME token appeared at the very end of the input
1970 string, with no whitespace separating the name from the EOF. This
1971 is used only when parsing to do field name completion. */
1972 static int saw_name_at_eof;
1974 /* This is set if the previously-returned token was a structure
1975 operator -- either '.' or ARROW. This is used only when parsing to
1976 do field name completion. */
1977 static int last_was_structop;
1979 /* Read one token, getting characters through lexptr. */
1988 int saw_structop = last_was_structop;
1991 last_was_structop = 0;
1995 /* Check if this is a macro invocation that we need to expand. */
1996 if (! scanning_macro_expansion ())
1998 char *expanded = macro_expand_next (&lexptr,
1999 standard_macro_lookup,
2000 expression_macro_scope);
2003 scan_macro_expansion (expanded);
2006 prev_lexptr = lexptr;
2009 /* See if it is a special token of length 3. */
2010 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
2011 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
2013 if (tokentab3[i].cxx_only
2014 && parse_language->la_language != language_cplus)
2018 yylval.opcode = tokentab3[i].opcode;
2019 return tokentab3[i].token;
2022 /* See if it is a special token of length 2. */
2023 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
2024 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
2026 if (tokentab2[i].cxx_only
2027 && parse_language->la_language != language_cplus)
2031 yylval.opcode = tokentab2[i].opcode;
2032 if (in_parse_field && tokentab2[i].token == ARROW)
2033 last_was_structop = 1;
2034 return tokentab2[i].token;
2037 switch (c = *tokstart)
2040 /* If we were just scanning the result of a macro expansion,
2041 then we need to resume scanning the original text.
2042 If we're parsing for field name completion, and the previous
2043 token allows such completion, return a COMPLETE token.
2044 Otherwise, we were already scanning the original text, and
2045 we're really done. */
2046 if (scanning_macro_expansion ())
2048 finished_macro_expansion ();
2051 else if (saw_name_at_eof)
2053 saw_name_at_eof = 0;
2056 else if (saw_structop)
2075 if (paren_depth == 0)
2082 if (comma_terminates
2084 && ! scanning_macro_expansion ())
2090 /* Might be a floating point number. */
2091 if (lexptr[1] < '0' || lexptr[1] > '9')
2094 last_was_structop = 1;
2095 goto symbol; /* Nope, must be a symbol. */
2097 /* FALL THRU into number case. */
2110 /* It's a number. */
2111 int got_dot = 0, got_e = 0, toktype;
2113 int hex = input_radix > 10;
2115 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
2120 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
2128 /* This test includes !hex because 'e' is a valid hex digit
2129 and thus does not indicate a floating point number when
2130 the radix is hex. */
2131 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
2132 got_dot = got_e = 1;
2133 /* This test does not include !hex, because a '.' always indicates
2134 a decimal floating point number regardless of the radix. */
2135 else if (!got_dot && *p == '.')
2137 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
2138 && (*p == '-' || *p == '+'))
2139 /* This is the sign of the exponent, not the end of the
2142 /* We will take any letters or digits. parse_number will
2143 complain if past the radix, or if L or U are not final. */
2144 else if ((*p < '0' || *p > '9')
2145 && ((*p < 'a' || *p > 'z')
2146 && (*p < 'A' || *p > 'Z')))
2149 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
2150 if (toktype == ERROR)
2152 char *err_copy = (char *) alloca (p - tokstart + 1);
2154 memcpy (err_copy, tokstart, p - tokstart);
2155 err_copy[p - tokstart] = 0;
2156 error ("Invalid number \"%s\".", err_copy);
2187 if (tokstart[1] != '"' && tokstart[1] != '\'')
2194 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2199 error ("Empty character constant.");
2200 else if (host_len > 2 && c == '\'')
2203 namelen = lexptr - tokstart - 1;
2206 else if (host_len > 1)
2207 error ("Invalid character constant.");
2213 if (!(c == '_' || c == '$'
2214 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2215 /* We must have come across a bad character (e.g. ';'). */
2216 error ("Invalid character '%c' in expression.", c);
2218 /* It's a name. See how long it is. */
2220 for (c = tokstart[namelen];
2221 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2222 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2224 /* Template parameter lists are part of the name.
2225 FIXME: This mishandles `print $a<4&&$a>3'. */
2229 /* Scan ahead to get rest of the template specification. Note
2230 that we look ahead only when the '<' adjoins non-whitespace
2231 characters; for comparison expressions, e.g. "a < b > c",
2232 there must be spaces before the '<', etc. */
2234 char * p = find_template_name_end (tokstart + namelen);
2236 namelen = p - tokstart;
2239 c = tokstart[++namelen];
2242 /* The token "if" terminates the expression and is NOT removed from
2243 the input stream. It doesn't count if it appears in the
2244 expansion of a macro. */
2246 && tokstart[0] == 'i'
2247 && tokstart[1] == 'f'
2248 && ! scanning_macro_expansion ())
2257 yylval.sval.ptr = tokstart;
2258 yylval.sval.length = namelen;
2260 /* Catch specific keywords. */
2261 copy = copy_name (yylval.sval);
2262 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2263 if (strcmp (copy, ident_tokens[i].operator) == 0)
2265 if (ident_tokens[i].cxx_only
2266 && parse_language->la_language != language_cplus)
2269 /* It is ok to always set this, even though we don't always
2270 strictly need to. */
2271 yylval.opcode = ident_tokens[i].opcode;
2272 return ident_tokens[i].token;
2275 if (*tokstart == '$')
2277 write_dollar_variable (yylval.sval);
2281 /* Use token-type BLOCKNAME for symbols that happen to be defined as
2282 functions or symtabs. If this is not so, then ...
2283 Use token-type TYPENAME for symbols that happen to be defined
2284 currently as names of types; NAME for other symbols.
2285 The caller is not constrained to care about the distinction. */
2288 int is_a_field_of_this = 0;
2291 sym = lookup_symbol (copy, expression_context_block,
2293 parse_language->la_language == language_cplus
2294 ? &is_a_field_of_this : (int *) NULL);
2295 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
2296 no psymtabs (coff, xcoff, or some future change to blow away the
2297 psymtabs once once symbols are read). */
2298 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2300 yylval.ssym.sym = sym;
2301 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2305 { /* See if it's a file name. */
2306 struct symtab *symtab;
2308 symtab = lookup_symtab (copy);
2312 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2317 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2319 /* NOTE: carlton/2003-09-25: There used to be code here to
2320 handle nested types. It didn't work very well. See the
2321 comment before qualified_type for more info. */
2322 yylval.tsym.type = SYMBOL_TYPE (sym);
2326 = language_lookup_primitive_type_by_name (parse_language,
2327 parse_gdbarch, copy);
2328 if (yylval.tsym.type != NULL)
2331 /* Input names that aren't symbols but ARE valid hex numbers,
2332 when the input radix permits them, can be names or numbers
2333 depending on the parse. Note we support radixes > 16 here. */
2335 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
2336 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2338 YYSTYPE newlval; /* Its value is ignored. */
2339 hextype = parse_number (tokstart, namelen, 0, &newlval);
2342 yylval.ssym.sym = sym;
2343 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2348 /* Any other kind of symbol */
2349 yylval.ssym.sym = sym;
2350 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2351 if (in_parse_field && *lexptr == '\0')
2352 saw_name_at_eof = 1;
2361 struct cleanup *back_to = make_cleanup (free_current_contents,
2362 &expression_macro_scope);
2364 /* Set up the scope for macro expansion. */
2365 expression_macro_scope = NULL;
2367 if (expression_context_block)
2368 expression_macro_scope
2369 = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2371 expression_macro_scope = default_macro_scope ();
2372 if (! expression_macro_scope)
2373 expression_macro_scope = user_macro_scope ();
2375 /* Initialize macro expansion code. */
2376 obstack_init (&expansion_obstack);
2377 gdb_assert (! macro_original_text);
2378 make_cleanup (scan_macro_cleanup, 0);
2380 /* Initialize some state used by the lexer. */
2381 last_was_structop = 0;
2382 saw_name_at_eof = 0;
2384 result = yyparse ();
2385 do_cleanups (back_to);
2394 lexptr = prev_lexptr;
2396 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);