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 *);
162 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
164 %type <tval> type typebase qualified_type
165 %type <tvec> nonempty_typelist
166 /* %type <bval> block */
168 /* Fancy type parsing. */
169 %type <voidval> func_mod direct_abs_decl abs_decl
171 %type <lval> array_mod
173 %token <typed_val_int> INT
174 %token <typed_val_float> FLOAT
175 %token <typed_val_decfloat> DECFLOAT
177 /* Both NAME and TYPENAME tokens represent symbols in the input,
178 and both convey their data as strings.
179 But a TYPENAME is a string that happens to be defined as a typedef
180 or builtin type name (such as int or char)
181 and a NAME is any other symbol.
182 Contexts where this distinction is not important can use the
183 nonterminal "name", which matches either NAME or TYPENAME. */
185 %token <tsval> STRING
187 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
188 %token <voidval> COMPLETE
189 %token <tsym> TYPENAME
191 %type <svec> string_exp
192 %type <ssym> name_not_typename
193 %type <tsym> typename
195 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
196 but which would parse as a valid number in the current input radix.
197 E.g. "c" when input_radix==16. Depending on the parse, it will be
198 turned into a name or into a number. */
200 %token <ssym> NAME_OR_INT
202 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
206 /* Special type cases, put in to allow the parser to distinguish different
208 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
210 %token <voidval> VARIABLE
212 %token <opcode> ASSIGN_MODIFY
221 %right '=' ASSIGN_MODIFY
229 %left '<' '>' LEQ GEQ
234 %right UNARY INCREMENT DECREMENT
235 %right ARROW ARROW_STAR '.' DOT_STAR '[' '('
236 %token <ssym> BLOCKNAME
237 %token <bval> FILENAME
249 { write_exp_elt_opcode(OP_TYPE);
250 write_exp_elt_type($1);
251 write_exp_elt_opcode(OP_TYPE);}
254 /* Expressions, including the comma operator. */
257 { write_exp_elt_opcode (BINOP_COMMA); }
260 /* Expressions, not including the comma operator. */
261 exp : '*' exp %prec UNARY
262 { write_exp_elt_opcode (UNOP_IND); }
265 exp : '&' exp %prec UNARY
266 { write_exp_elt_opcode (UNOP_ADDR); }
269 exp : '-' exp %prec UNARY
270 { write_exp_elt_opcode (UNOP_NEG); }
273 exp : '+' exp %prec UNARY
274 { write_exp_elt_opcode (UNOP_PLUS); }
277 exp : '!' exp %prec UNARY
278 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
281 exp : '~' exp %prec UNARY
282 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
285 exp : INCREMENT exp %prec UNARY
286 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
289 exp : DECREMENT exp %prec UNARY
290 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
293 exp : exp INCREMENT %prec UNARY
294 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
297 exp : exp DECREMENT %prec UNARY
298 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
301 exp : SIZEOF exp %prec UNARY
302 { write_exp_elt_opcode (UNOP_SIZEOF); }
306 { write_exp_elt_opcode (STRUCTOP_PTR);
307 write_exp_string ($3);
308 write_exp_elt_opcode (STRUCTOP_PTR); }
311 exp : exp ARROW name COMPLETE
312 { mark_struct_expression ();
313 write_exp_elt_opcode (STRUCTOP_PTR);
314 write_exp_string ($3);
315 write_exp_elt_opcode (STRUCTOP_PTR); }
318 exp : exp ARROW COMPLETE
320 mark_struct_expression ();
321 write_exp_elt_opcode (STRUCTOP_PTR);
324 write_exp_string (s);
325 write_exp_elt_opcode (STRUCTOP_PTR); }
328 exp : exp ARROW qualified_name
329 { /* exp->type::name becomes exp->*(&type::name) */
330 /* Note: this doesn't work if name is a
331 static member! FIXME */
332 write_exp_elt_opcode (UNOP_ADDR);
333 write_exp_elt_opcode (STRUCTOP_MPTR); }
336 exp : exp ARROW_STAR exp
337 { write_exp_elt_opcode (STRUCTOP_MPTR); }
341 { write_exp_elt_opcode (STRUCTOP_STRUCT);
342 write_exp_string ($3);
343 write_exp_elt_opcode (STRUCTOP_STRUCT); }
346 exp : exp '.' name COMPLETE
347 { mark_struct_expression ();
348 write_exp_elt_opcode (STRUCTOP_STRUCT);
349 write_exp_string ($3);
350 write_exp_elt_opcode (STRUCTOP_STRUCT); }
353 exp : exp '.' COMPLETE
355 mark_struct_expression ();
356 write_exp_elt_opcode (STRUCTOP_STRUCT);
359 write_exp_string (s);
360 write_exp_elt_opcode (STRUCTOP_STRUCT); }
363 exp : exp '.' qualified_name
364 { /* exp.type::name becomes exp.*(&type::name) */
365 /* Note: this doesn't work if name is a
366 static member! FIXME */
367 write_exp_elt_opcode (UNOP_ADDR);
368 write_exp_elt_opcode (STRUCTOP_MEMBER); }
371 exp : exp DOT_STAR exp
372 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
375 exp : exp '[' exp1 ']'
376 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
380 /* This is to save the value of arglist_len
381 being accumulated by an outer function call. */
382 { start_arglist (); }
383 arglist ')' %prec ARROW
384 { write_exp_elt_opcode (OP_FUNCALL);
385 write_exp_elt_longcst ((LONGEST) end_arglist ());
386 write_exp_elt_opcode (OP_FUNCALL); }
390 { start_arglist (); }
400 arglist : arglist ',' exp %prec ABOVE_COMMA
405 { $$ = end_arglist () - 1; }
407 exp : lcurly arglist rcurly %prec ARROW
408 { write_exp_elt_opcode (OP_ARRAY);
409 write_exp_elt_longcst ((LONGEST) 0);
410 write_exp_elt_longcst ((LONGEST) $3);
411 write_exp_elt_opcode (OP_ARRAY); }
414 exp : lcurly type rcurly exp %prec UNARY
415 { write_exp_elt_opcode (UNOP_MEMVAL);
416 write_exp_elt_type ($2);
417 write_exp_elt_opcode (UNOP_MEMVAL); }
420 exp : '(' type ')' exp %prec UNARY
421 { write_exp_elt_opcode (UNOP_CAST);
422 write_exp_elt_type ($2);
423 write_exp_elt_opcode (UNOP_CAST); }
430 /* Binary operators in order of decreasing precedence. */
433 { write_exp_elt_opcode (BINOP_REPEAT); }
437 { write_exp_elt_opcode (BINOP_MUL); }
441 { write_exp_elt_opcode (BINOP_DIV); }
445 { write_exp_elt_opcode (BINOP_REM); }
449 { write_exp_elt_opcode (BINOP_ADD); }
453 { write_exp_elt_opcode (BINOP_SUB); }
457 { write_exp_elt_opcode (BINOP_LSH); }
461 { write_exp_elt_opcode (BINOP_RSH); }
465 { write_exp_elt_opcode (BINOP_EQUAL); }
468 exp : exp NOTEQUAL exp
469 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
473 { write_exp_elt_opcode (BINOP_LEQ); }
477 { write_exp_elt_opcode (BINOP_GEQ); }
481 { write_exp_elt_opcode (BINOP_LESS); }
485 { write_exp_elt_opcode (BINOP_GTR); }
489 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
493 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
497 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
501 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
505 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
508 exp : exp '?' exp ':' exp %prec '?'
509 { write_exp_elt_opcode (TERNOP_COND); }
513 { write_exp_elt_opcode (BINOP_ASSIGN); }
516 exp : exp ASSIGN_MODIFY exp
517 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
518 write_exp_elt_opcode ($2);
519 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
523 { write_exp_elt_opcode (OP_LONG);
524 write_exp_elt_type ($1.type);
525 write_exp_elt_longcst ((LONGEST)($1.val));
526 write_exp_elt_opcode (OP_LONG); }
531 struct stoken_vector vec;
534 write_exp_string_vector ($1.type, &vec);
540 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
541 write_exp_elt_opcode (OP_LONG);
542 write_exp_elt_type (val.typed_val_int.type);
543 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
544 write_exp_elt_opcode (OP_LONG);
550 { write_exp_elt_opcode (OP_DOUBLE);
551 write_exp_elt_type ($1.type);
552 write_exp_elt_dblcst ($1.dval);
553 write_exp_elt_opcode (OP_DOUBLE); }
557 { write_exp_elt_opcode (OP_DECFLOAT);
558 write_exp_elt_type ($1.type);
559 write_exp_elt_decfloatcst ($1.val);
560 write_exp_elt_opcode (OP_DECFLOAT); }
567 /* Already written by write_dollar_variable. */
570 exp : SIZEOF '(' type ')' %prec UNARY
571 { write_exp_elt_opcode (OP_LONG);
572 write_exp_elt_type (parse_type->builtin_int);
574 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
575 write_exp_elt_opcode (OP_LONG); }
581 /* We copy the string here, and not in the
582 lexer, to guarantee that we do not leak a
583 string. Note that we follow the
584 NUL-termination convention of the
586 struct typed_stoken *vec = XNEW (struct typed_stoken);
591 vec->length = $1.length;
592 vec->ptr = malloc ($1.length + 1);
593 memcpy (vec->ptr, $1.ptr, $1.length + 1);
598 /* Note that we NUL-terminate here, but just
602 $$.tokens = realloc ($$.tokens,
603 $$.len * sizeof (struct typed_stoken));
605 p = malloc ($2.length + 1);
606 memcpy (p, $2.ptr, $2.length + 1);
608 $$.tokens[$$.len - 1].type = $2.type;
609 $$.tokens[$$.len - 1].length = $2.length;
610 $$.tokens[$$.len - 1].ptr = p;
617 enum c_string_type type = C_STRING;
619 for (i = 0; i < $1.len; ++i)
621 switch ($1.tokens[i].type)
629 && type != $1.tokens[i].type)
630 error ("Undefined string concatenation.");
631 type = $1.tokens[i].type;
635 internal_error (__FILE__, __LINE__,
636 "unrecognized type in string concatenation");
640 write_exp_string_vector (type, &$1);
641 for (i = 0; i < $1.len; ++i)
642 free ($1.tokens[i].ptr);
649 { write_exp_elt_opcode (OP_LONG);
650 write_exp_elt_type (parse_type->builtin_bool);
651 write_exp_elt_longcst ((LONGEST) 1);
652 write_exp_elt_opcode (OP_LONG); }
656 { write_exp_elt_opcode (OP_LONG);
657 write_exp_elt_type (parse_type->builtin_bool);
658 write_exp_elt_longcst ((LONGEST) 0);
659 write_exp_elt_opcode (OP_LONG); }
667 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
669 error ("No file or function \"%s\".",
670 copy_name ($1.stoken));
678 block : block COLONCOLON name
680 = lookup_symbol (copy_name ($3), $1,
681 VAR_DOMAIN, (int *) NULL);
682 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
683 error ("No function \"%s\" in specified context.",
685 $$ = SYMBOL_BLOCK_VALUE (tem); }
688 variable: block COLONCOLON name
689 { struct symbol *sym;
690 sym = lookup_symbol (copy_name ($3), $1,
691 VAR_DOMAIN, (int *) NULL);
693 error ("No symbol \"%s\" in specified context.",
696 write_exp_elt_opcode (OP_VAR_VALUE);
697 /* block_found is set by lookup_symbol. */
698 write_exp_elt_block (block_found);
699 write_exp_elt_sym (sym);
700 write_exp_elt_opcode (OP_VAR_VALUE); }
703 qualified_name: typebase COLONCOLON name
705 struct type *type = $1;
706 CHECK_TYPEDEF (type);
707 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
708 && TYPE_CODE (type) != TYPE_CODE_UNION
709 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
710 error ("`%s' is not defined as an aggregate type.",
713 write_exp_elt_opcode (OP_SCOPE);
714 write_exp_elt_type (type);
715 write_exp_string ($3);
716 write_exp_elt_opcode (OP_SCOPE);
718 | typebase COLONCOLON '~' name
720 struct type *type = $1;
721 struct stoken tmp_token;
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 tmp_token.ptr = (char*) alloca ($4.length + 2);
730 tmp_token.length = $4.length + 1;
731 tmp_token.ptr[0] = '~';
732 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
733 tmp_token.ptr[tmp_token.length] = 0;
735 /* Check for valid destructor name. */
736 destructor_name_p (tmp_token.ptr, type);
737 write_exp_elt_opcode (OP_SCOPE);
738 write_exp_elt_type (type);
739 write_exp_string (tmp_token);
740 write_exp_elt_opcode (OP_SCOPE);
744 variable: qualified_name
747 char *name = copy_name ($2);
749 struct minimal_symbol *msymbol;
752 lookup_symbol (name, (const struct block *) NULL,
753 VAR_DOMAIN, (int *) NULL);
756 write_exp_elt_opcode (OP_VAR_VALUE);
757 write_exp_elt_block (NULL);
758 write_exp_elt_sym (sym);
759 write_exp_elt_opcode (OP_VAR_VALUE);
763 msymbol = lookup_minimal_symbol (name, NULL, NULL);
765 write_exp_msymbol (msymbol);
766 else if (!have_full_symbols () && !have_partial_symbols ())
767 error ("No symbol table is loaded. Use the \"file\" command.");
769 error ("No symbol \"%s\" in current context.", name);
773 variable: name_not_typename
774 { struct symbol *sym = $1.sym;
778 if (symbol_read_needs_frame (sym))
780 if (innermost_block == 0 ||
781 contained_in (block_found,
783 innermost_block = block_found;
786 write_exp_elt_opcode (OP_VAR_VALUE);
787 /* We want to use the selected frame, not
788 another more inner frame which happens to
789 be in the same block. */
790 write_exp_elt_block (NULL);
791 write_exp_elt_sym (sym);
792 write_exp_elt_opcode (OP_VAR_VALUE);
794 else if ($1.is_a_field_of_this)
796 /* C++: it hangs off of `this'. Must
797 not inadvertently convert from a method call
799 if (innermost_block == 0 ||
800 contained_in (block_found, innermost_block))
801 innermost_block = block_found;
802 write_exp_elt_opcode (OP_THIS);
803 write_exp_elt_opcode (OP_THIS);
804 write_exp_elt_opcode (STRUCTOP_PTR);
805 write_exp_string ($1.stoken);
806 write_exp_elt_opcode (STRUCTOP_PTR);
810 struct minimal_symbol *msymbol;
811 char *arg = copy_name ($1.stoken);
814 lookup_minimal_symbol (arg, NULL, NULL);
816 write_exp_msymbol (msymbol);
817 else if (!have_full_symbols () && !have_partial_symbols ())
818 error ("No symbol table is loaded. Use the \"file\" command.");
820 error ("No symbol \"%s\" in current context.",
821 copy_name ($1.stoken));
826 space_identifier : '@' NAME
827 { push_type_address_space (copy_name ($2.stoken));
828 push_type (tp_space_identifier);
832 const_or_volatile: const_or_volatile_noopt
836 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
839 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
840 | const_or_volatile_noopt
843 const_or_volatile_or_space_identifier:
844 const_or_volatile_or_space_identifier_noopt
849 { push_type (tp_pointer); $$ = 0; }
851 { push_type (tp_pointer); $$ = $2; }
853 { push_type (tp_reference); $$ = 0; }
855 { push_type (tp_reference); $$ = $2; }
859 direct_abs_decl: '(' abs_decl ')'
861 | direct_abs_decl array_mod
864 push_type (tp_array);
869 push_type (tp_array);
873 | direct_abs_decl func_mod
874 { push_type (tp_function); }
876 { push_type (tp_function); }
887 | '(' nonempty_typelist ')'
888 { free ($2); $$ = 0; }
891 /* We used to try to recognize pointer to member types here, but
892 that didn't work (shift/reduce conflicts meant that these rules never
893 got executed). The problem is that
894 int (foo::bar::baz::bizzle)
895 is a function type but
896 int (foo::bar::baz::bizzle::*)
897 is a pointer to member type. Stroustrup loses again! */
902 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
906 { $$ = parse_type->builtin_int; }
908 { $$ = parse_type->builtin_long; }
910 { $$ = parse_type->builtin_short; }
912 { $$ = parse_type->builtin_long; }
913 | LONG SIGNED_KEYWORD INT_KEYWORD
914 { $$ = parse_type->builtin_long; }
915 | LONG SIGNED_KEYWORD
916 { $$ = parse_type->builtin_long; }
917 | SIGNED_KEYWORD LONG INT_KEYWORD
918 { $$ = parse_type->builtin_long; }
919 | UNSIGNED LONG INT_KEYWORD
920 { $$ = parse_type->builtin_unsigned_long; }
921 | LONG UNSIGNED INT_KEYWORD
922 { $$ = parse_type->builtin_unsigned_long; }
924 { $$ = parse_type->builtin_unsigned_long; }
926 { $$ = parse_type->builtin_long_long; }
927 | LONG LONG INT_KEYWORD
928 { $$ = parse_type->builtin_long_long; }
929 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
930 { $$ = parse_type->builtin_long_long; }
931 | LONG LONG SIGNED_KEYWORD
932 { $$ = parse_type->builtin_long_long; }
933 | SIGNED_KEYWORD LONG LONG
934 { $$ = parse_type->builtin_long_long; }
935 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
936 { $$ = parse_type->builtin_long_long; }
938 { $$ = parse_type->builtin_unsigned_long_long; }
939 | UNSIGNED LONG LONG INT_KEYWORD
940 { $$ = parse_type->builtin_unsigned_long_long; }
942 { $$ = parse_type->builtin_unsigned_long_long; }
943 | LONG LONG UNSIGNED INT_KEYWORD
944 { $$ = parse_type->builtin_unsigned_long_long; }
946 { $$ = parse_type->builtin_short; }
947 | SHORT SIGNED_KEYWORD INT_KEYWORD
948 { $$ = parse_type->builtin_short; }
949 | SHORT SIGNED_KEYWORD
950 { $$ = parse_type->builtin_short; }
951 | UNSIGNED SHORT INT_KEYWORD
952 { $$ = parse_type->builtin_unsigned_short; }
954 { $$ = parse_type->builtin_unsigned_short; }
955 | SHORT UNSIGNED INT_KEYWORD
956 { $$ = parse_type->builtin_unsigned_short; }
958 { $$ = parse_type->builtin_double; }
959 | LONG DOUBLE_KEYWORD
960 { $$ = parse_type->builtin_long_double; }
962 { $$ = lookup_struct (copy_name ($2),
963 expression_context_block); }
965 { $$ = lookup_struct (copy_name ($2),
966 expression_context_block); }
968 { $$ = lookup_union (copy_name ($2),
969 expression_context_block); }
971 { $$ = lookup_enum (copy_name ($2),
972 expression_context_block); }
974 { $$ = lookup_unsigned_typename (parse_language,
976 TYPE_NAME($2.type)); }
978 { $$ = parse_type->builtin_unsigned_int; }
979 | SIGNED_KEYWORD typename
980 { $$ = lookup_signed_typename (parse_language,
982 TYPE_NAME($2.type)); }
984 { $$ = parse_type->builtin_int; }
985 /* It appears that this rule for templates is never
986 reduced; template recognition happens by lookahead
987 in the token processing code in yylex. */
988 | TEMPLATE name '<' type '>'
989 { $$ = lookup_template_type(copy_name($2), $4,
990 expression_context_block);
992 | const_or_volatile_or_space_identifier_noopt typebase
993 { $$ = follow_types ($2); }
994 | typebase const_or_volatile_or_space_identifier_noopt
995 { $$ = follow_types ($1); }
999 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
1000 reduce-reduce conflicts, because the parser doesn't know whether or
1001 not to use qualified_name or qualified_type: the rules are
1002 identical. If the parser is parsing 'A::B::x', then, when it sees
1003 the second '::', it knows that the expression to the left of it has
1004 to be a type, so it uses qualified_type. But if it is parsing just
1005 'A::B', then it doesn't have any way of knowing which rule to use,
1006 so there's a reduce-reduce conflict; it picks qualified_name, since
1007 that occurs earlier in this file than qualified_type.
1009 There's no good way to fix this with the grammar as it stands; as
1010 far as I can tell, some of the problems arise from ambiguities that
1011 GDB introduces ('start' can be either an expression or a type), but
1012 some of it is inherent to the nature of C++ (you want to treat the
1013 input "(FOO)" fairly differently depending on whether FOO is an
1014 expression or a type, and if FOO is a complex expression, this can
1015 be hard to determine at the right time). Fortunately, it works
1016 pretty well in most cases. For example, if you do 'ptype A::B',
1017 where A::B is a nested type, then the parser will mistakenly
1018 misidentify it as an expression; but evaluate_subexp will get
1019 called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
1020 will work out anyways. But there are situations where the parser
1021 will get confused: the most common one that I've run into is when
1024 print *((A::B *) x)"
1026 where the parser doesn't realize that A::B has to be a type until
1027 it hits the first right paren, at which point it's too late. (The
1028 workaround is to type "print *(('A::B' *) x)" instead.) (And
1029 another solution is to fix our symbol-handling code so that the
1030 user never wants to type something like that in the first place,
1031 because we get all the types right without the user's help!)
1033 Perhaps we could fix this by making the lexer smarter. Some of
1034 this functionality used to be in the lexer, but in a way that
1035 worked even less well than the current solution: that attempt
1036 involved having the parser sometimes handle '::' and having the
1037 lexer sometimes handle it, and without a clear division of
1038 responsibility, it quickly degenerated into a big mess. Probably
1039 the eventual correct solution will give more of a role to the lexer
1040 (ideally via code that is shared between the lexer and
1041 decode_line_1), but I'm not holding my breath waiting for somebody
1042 to get around to cleaning this up... */
1044 qualified_type: typebase COLONCOLON name
1046 struct type *type = $1;
1047 struct type *new_type;
1048 char *ncopy = alloca ($3.length + 1);
1050 memcpy (ncopy, $3.ptr, $3.length);
1051 ncopy[$3.length] = '\0';
1053 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
1054 && TYPE_CODE (type) != TYPE_CODE_UNION
1055 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
1056 error ("`%s' is not defined as an aggregate type.",
1059 new_type = cp_lookup_nested_type (type, ncopy,
1060 expression_context_block);
1061 if (new_type == NULL)
1062 error ("No type \"%s\" within class or namespace \"%s\".",
1063 ncopy, TYPE_NAME (type));
1072 $$.stoken.ptr = "int";
1073 $$.stoken.length = 3;
1074 $$.type = parse_type->builtin_int;
1078 $$.stoken.ptr = "long";
1079 $$.stoken.length = 4;
1080 $$.type = parse_type->builtin_long;
1084 $$.stoken.ptr = "short";
1085 $$.stoken.length = 5;
1086 $$.type = parse_type->builtin_short;
1092 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1093 $<ivec>$[0] = 1; /* Number of types in vector */
1096 | nonempty_typelist ',' type
1097 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1098 $$ = (struct type **) realloc ((char *) $1, len);
1099 $$[$<ivec>$[0]] = $3;
1104 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1105 { $$ = follow_types ($1); }
1108 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1109 | VOLATILE_KEYWORD CONST_KEYWORD
1112 const_or_volatile_noopt: const_and_volatile
1113 { push_type (tp_const);
1114 push_type (tp_volatile);
1117 { push_type (tp_const); }
1119 { push_type (tp_volatile); }
1122 name : NAME { $$ = $1.stoken; }
1123 | BLOCKNAME { $$ = $1.stoken; }
1124 | TYPENAME { $$ = $1.stoken; }
1125 | NAME_OR_INT { $$ = $1.stoken; }
1128 name_not_typename : NAME
1130 /* These would be useful if name_not_typename was useful, but it is just
1131 a fake for "variable", so these cause reduce/reduce conflicts because
1132 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1133 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1134 context where only a name could occur, this might be useful.
1141 /* Take care of parsing a number (anything that starts with a digit).
1142 Set yylval and return the token type; update lexptr.
1143 LEN is the number of characters in it. */
1145 /*** Needs some error checking for the float case ***/
1148 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
1150 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1151 here, and we do kind of silly things like cast to unsigned. */
1158 int base = input_radix;
1161 /* Number of "L" suffixes encountered. */
1164 /* We have found a "L" or "U" suffix. */
1165 int found_suffix = 0;
1168 struct type *signed_type;
1169 struct type *unsigned_type;
1173 /* It's a float since it contains a point or an exponent. */
1175 int num; /* number of tokens scanned by scanf */
1178 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1179 point. Return DECFLOAT. */
1181 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'f')
1184 putithere->typed_val_decfloat.type
1185 = parse_type->builtin_decfloat;
1186 decimal_from_string (putithere->typed_val_decfloat.val, 4,
1187 gdbarch_byte_order (parse_gdbarch), p);
1192 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'd')
1195 putithere->typed_val_decfloat.type
1196 = parse_type->builtin_decdouble;
1197 decimal_from_string (putithere->typed_val_decfloat.val, 8,
1198 gdbarch_byte_order (parse_gdbarch), p);
1203 if (len >= 2 && p[len - 2] == 'd' && p[len - 1] == 'l')
1206 putithere->typed_val_decfloat.type
1207 = parse_type->builtin_declong;
1208 decimal_from_string (putithere->typed_val_decfloat.val, 16,
1209 gdbarch_byte_order (parse_gdbarch), p);
1215 saved_char = p[len];
1216 p[len] = 0; /* null-terminate the token */
1217 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
1218 &putithere->typed_val_float.dval, s);
1219 p[len] = saved_char; /* restore the input stream */
1222 putithere->typed_val_float.type =
1223 parse_type->builtin_double;
1227 /* See if it has any float suffix: 'f' for float, 'l' for long
1229 if (!strcasecmp (s, "f"))
1230 putithere->typed_val_float.type =
1231 parse_type->builtin_float;
1232 else if (!strcasecmp (s, "l"))
1233 putithere->typed_val_float.type =
1234 parse_type->builtin_long_double;
1246 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1280 if (c >= 'A' && c <= 'Z')
1282 if (c != 'l' && c != 'u')
1284 if (c >= '0' && c <= '9')
1292 if (base > 10 && c >= 'a' && c <= 'f')
1296 n += i = c - 'a' + 10;
1309 return ERROR; /* Char not a digit */
1312 return ERROR; /* Invalid digit in this base */
1314 /* Portably test for overflow (only works for nonzero values, so make
1315 a second check for zero). FIXME: Can't we just make n and prevn
1316 unsigned and avoid this? */
1317 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1318 unsigned_p = 1; /* Try something unsigned */
1320 /* Portably test for unsigned overflow.
1321 FIXME: This check is wrong; for example it doesn't find overflow
1322 on 0x123456789 when LONGEST is 32 bits. */
1323 if (c != 'l' && c != 'u' && n != 0)
1325 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1326 error ("Numeric constant too large.");
1331 /* An integer constant is an int, a long, or a long long. An L
1332 suffix forces it to be long; an LL suffix forces it to be long
1333 long. If not forced to a larger size, it gets the first type of
1334 the above that it fits in. To figure out whether it fits, we
1335 shift it right and see whether anything remains. Note that we
1336 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1337 operation, because many compilers will warn about such a shift
1338 (which always produces a zero result). Sometimes gdbarch_int_bit
1339 or gdbarch_long_bit will be that big, sometimes not. To deal with
1340 the case where it is we just always shift the value more than
1341 once, with fewer bits each time. */
1343 un = (ULONGEST)n >> 2;
1345 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
1347 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
1349 /* A large decimal (not hex or octal) constant (between INT_MAX
1350 and UINT_MAX) is a long or unsigned long, according to ANSI,
1351 never an unsigned int, but this code treats it as unsigned
1352 int. This probably should be fixed. GCC gives a warning on
1355 unsigned_type = parse_type->builtin_unsigned_int;
1356 signed_type = parse_type->builtin_int;
1358 else if (long_p <= 1
1359 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
1361 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
1362 unsigned_type = parse_type->builtin_unsigned_long;
1363 signed_type = parse_type->builtin_long;
1368 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1369 < gdbarch_long_long_bit (parse_gdbarch))
1370 /* A long long does not fit in a LONGEST. */
1371 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1373 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
1374 high_bit = (ULONGEST) 1 << shift;
1375 unsigned_type = parse_type->builtin_unsigned_long_long;
1376 signed_type = parse_type->builtin_long_long;
1379 putithere->typed_val_int.val = n;
1381 /* If the high bit of the worked out type is set then this number
1382 has to be unsigned. */
1384 if (unsigned_p || (n & high_bit))
1386 putithere->typed_val_int.type = unsigned_type;
1390 putithere->typed_val_int.type = signed_type;
1396 /* Temporary obstack used for holding strings. */
1397 static struct obstack tempbuf;
1398 static int tempbuf_init;
1400 /* Parse a C escape sequence. The initial backslash of the sequence
1401 is at (*PTR)[-1]. *PTR will be updated to point to just after the
1402 last character of the sequence. If OUTPUT is not NULL, the
1403 translated form of the escape sequence will be written there. If
1404 OUTPUT is NULL, no output is written and the call will only affect
1405 *PTR. If an escape sequence is expressed in target bytes, then the
1406 entire sequence will simply be copied to OUTPUT. Return 1 if any
1407 character was emitted, 0 otherwise. */
1410 c_parse_escape (char **ptr, struct obstack *output)
1412 char *tokptr = *ptr;
1415 /* Some escape sequences undergo character set conversion. Those we
1419 /* Hex escapes do not undergo character set conversion, so keep
1420 the escape sequence for later. */
1423 obstack_grow_str (output, "\\x");
1425 if (!isxdigit (*tokptr))
1426 error (_("\\x escape without a following hex digit"));
1427 while (isxdigit (*tokptr))
1430 obstack_1grow (output, *tokptr);
1435 /* Octal escapes do not undergo character set conversion, so
1436 keep the escape sequence for later. */
1448 obstack_grow_str (output, "\\");
1450 i < 3 && isdigit (*tokptr) && *tokptr != '8' && *tokptr != '9';
1454 obstack_1grow (output, *tokptr);
1460 /* We handle UCNs later. We could handle them here, but that
1461 would mean a spurious error in the case where the UCN could
1462 be converted to the target charset but not the host
1468 int i, len = c == 'U' ? 8 : 4;
1471 obstack_1grow (output, '\\');
1472 obstack_1grow (output, *tokptr);
1475 if (!isxdigit (*tokptr))
1476 error (_("\\%c escape without a following hex digit"), c);
1477 for (i = 0; i < len && isxdigit (*tokptr); ++i)
1480 obstack_1grow (output, *tokptr);
1486 /* We must pass backslash through so that it does not
1487 cause quoting during the second expansion. */
1490 obstack_grow_str (output, "\\\\");
1494 /* Escapes which undergo conversion. */
1497 obstack_1grow (output, '\a');
1502 obstack_1grow (output, '\b');
1507 obstack_1grow (output, '\f');
1512 obstack_1grow (output, '\n');
1517 obstack_1grow (output, '\r');
1522 obstack_1grow (output, '\t');
1527 obstack_1grow (output, '\v');
1531 /* GCC extension. */
1534 obstack_1grow (output, HOST_ESCAPE_CHAR);
1538 /* Backslash-newline expands to nothing at all. */
1544 /* A few escapes just expand to the character itself. */
1548 /* GCC extensions. */
1553 /* Unrecognized escapes turn into the character itself. */
1556 obstack_1grow (output, *tokptr);
1564 /* Parse a string or character literal from TOKPTR. The string or
1565 character may be wide or unicode. *OUTPTR is set to just after the
1566 end of the literal in the input string. The resulting token is
1567 stored in VALUE. This returns a token value, either STRING or
1568 CHAR, depending on what was parsed. *HOST_CHARS is set to the
1569 number of host characters in the literal. */
1571 parse_string_or_char (char *tokptr, char **outptr, struct typed_stoken *value,
1575 enum c_string_type type;
1577 /* Build the gdb internal form of the input string in tempbuf. Note
1578 that the buffer is null byte terminated *only* for the
1579 convenience of debugging gdb itself and printing the buffer
1580 contents when the buffer contains no embedded nulls. Gdb does
1581 not depend upon the buffer being null byte terminated, it uses
1582 the length string instead. This allows gdb to handle C strings
1583 (as well as strings in other languages) with embedded null
1589 obstack_free (&tempbuf, NULL);
1590 obstack_init (&tempbuf);
1592 /* Record the string type. */
1595 type = C_WIDE_STRING;
1598 else if (*tokptr == 'u')
1603 else if (*tokptr == 'U')
1611 /* Skip the quote. */
1625 *host_chars += c_parse_escape (&tokptr, &tempbuf);
1627 else if (c == quote)
1631 obstack_1grow (&tempbuf, c);
1633 /* FIXME: this does the wrong thing with multi-byte host
1634 characters. We could use mbrlen here, but that would
1635 make "set host-charset" a bit less useful. */
1640 if (*tokptr != quote)
1643 error ("Unterminated string in expression.");
1645 error ("Unmatched single quote.");
1650 value->ptr = obstack_base (&tempbuf);
1651 value->length = obstack_object_size (&tempbuf);
1655 return quote == '"' ? STRING : CHAR;
1662 enum exp_opcode opcode;
1666 static const struct token tokentab3[] =
1668 {">>=", ASSIGN_MODIFY, BINOP_RSH, 0},
1669 {"<<=", ASSIGN_MODIFY, BINOP_LSH, 0},
1670 {"->*", ARROW_STAR, BINOP_END, 1}
1673 static const struct token tokentab2[] =
1675 {"+=", ASSIGN_MODIFY, BINOP_ADD, 0},
1676 {"-=", ASSIGN_MODIFY, BINOP_SUB, 0},
1677 {"*=", ASSIGN_MODIFY, BINOP_MUL, 0},
1678 {"/=", ASSIGN_MODIFY, BINOP_DIV, 0},
1679 {"%=", ASSIGN_MODIFY, BINOP_REM, 0},
1680 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 0},
1681 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND, 0},
1682 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 0},
1683 {"++", INCREMENT, BINOP_END, 0},
1684 {"--", DECREMENT, BINOP_END, 0},
1685 {"->", ARROW, BINOP_END, 0},
1686 {"&&", ANDAND, BINOP_END, 0},
1687 {"||", OROR, BINOP_END, 0},
1688 /* "::" is *not* only C++: gdb overrides its meaning in several
1689 different ways, e.g., 'filename'::func, function::variable. */
1690 {"::", COLONCOLON, BINOP_END, 0},
1691 {"<<", LSH, BINOP_END, 0},
1692 {">>", RSH, BINOP_END, 0},
1693 {"==", EQUAL, BINOP_END, 0},
1694 {"!=", NOTEQUAL, BINOP_END, 0},
1695 {"<=", LEQ, BINOP_END, 0},
1696 {">=", GEQ, BINOP_END, 0},
1697 {".*", DOT_STAR, BINOP_END, 1}
1700 /* Identifier-like tokens. */
1701 static const struct token ident_tokens[] =
1703 {"unsigned", UNSIGNED, OP_NULL, 0},
1704 {"template", TEMPLATE, OP_NULL, 1},
1705 {"volatile", VOLATILE_KEYWORD, OP_NULL, 0},
1706 {"struct", STRUCT, OP_NULL, 0},
1707 {"signed", SIGNED_KEYWORD, OP_NULL, 0},
1708 {"sizeof", SIZEOF, OP_NULL, 0},
1709 {"double", DOUBLE_KEYWORD, OP_NULL, 0},
1710 {"false", FALSEKEYWORD, OP_NULL, 1},
1711 {"class", CLASS, OP_NULL, 1},
1712 {"union", UNION, OP_NULL, 0},
1713 {"short", SHORT, OP_NULL, 0},
1714 {"const", CONST_KEYWORD, OP_NULL, 0},
1715 {"enum", ENUM, OP_NULL, 0},
1716 {"long", LONG, OP_NULL, 0},
1717 {"true", TRUEKEYWORD, OP_NULL, 1},
1718 {"int", INT_KEYWORD, OP_NULL, 0},
1720 {"and", ANDAND, BINOP_END, 1},
1721 {"and_eq", ASSIGN_MODIFY, BINOP_BITWISE_AND, 1},
1722 {"bitand", '&', OP_NULL, 1},
1723 {"bitor", '|', OP_NULL, 1},
1724 {"compl", '~', OP_NULL, 1},
1725 {"not", '!', OP_NULL, 1},
1726 {"not_eq", NOTEQUAL, BINOP_END, 1},
1727 {"or", OROR, BINOP_END, 1},
1728 {"or_eq", ASSIGN_MODIFY, BINOP_BITWISE_IOR, 1},
1729 {"xor", '^', OP_NULL, 1},
1730 {"xor_eq", ASSIGN_MODIFY, BINOP_BITWISE_XOR, 1}
1733 /* When we find that lexptr (the global var defined in parse.c) is
1734 pointing at a macro invocation, we expand the invocation, and call
1735 scan_macro_expansion to save the old lexptr here and point lexptr
1736 into the expanded text. When we reach the end of that, we call
1737 end_macro_expansion to pop back to the value we saved here. The
1738 macro expansion code promises to return only fully-expanded text,
1739 so we don't need to "push" more than one level.
1741 This is disgusting, of course. It would be cleaner to do all macro
1742 expansion beforehand, and then hand that to lexptr. But we don't
1743 really know where the expression ends. Remember, in a command like
1745 (gdb) break *ADDRESS if CONDITION
1747 we evaluate ADDRESS in the scope of the current frame, but we
1748 evaluate CONDITION in the scope of the breakpoint's location. So
1749 it's simply wrong to try to macro-expand the whole thing at once. */
1750 static char *macro_original_text;
1752 /* We save all intermediate macro expansions on this obstack for the
1753 duration of a single parse. The expansion text may sometimes have
1754 to live past the end of the expansion, due to yacc lookahead.
1755 Rather than try to be clever about saving the data for a single
1756 token, we simply keep it all and delete it after parsing has
1758 static struct obstack expansion_obstack;
1761 scan_macro_expansion (char *expansion)
1765 /* We'd better not be trying to push the stack twice. */
1766 gdb_assert (! macro_original_text);
1768 /* Copy to the obstack, and then free the intermediate
1770 copy = obstack_copy0 (&expansion_obstack, expansion, strlen (expansion));
1773 /* Save the old lexptr value, so we can return to it when we're done
1774 parsing the expanded text. */
1775 macro_original_text = lexptr;
1781 scanning_macro_expansion (void)
1783 return macro_original_text != 0;
1788 finished_macro_expansion (void)
1790 /* There'd better be something to pop back to. */
1791 gdb_assert (macro_original_text);
1793 /* Pop back to the original text. */
1794 lexptr = macro_original_text;
1795 macro_original_text = 0;
1800 scan_macro_cleanup (void *dummy)
1802 if (macro_original_text)
1803 finished_macro_expansion ();
1805 obstack_free (&expansion_obstack, NULL);
1809 /* The scope used for macro expansion. */
1810 static struct macro_scope *expression_macro_scope;
1812 /* This is set if a NAME token appeared at the very end of the input
1813 string, with no whitespace separating the name from the EOF. This
1814 is used only when parsing to do field name completion. */
1815 static int saw_name_at_eof;
1817 /* This is set if the previously-returned token was a structure
1818 operator -- either '.' or ARROW. This is used only when parsing to
1819 do field name completion. */
1820 static int last_was_structop;
1822 /* Read one token, getting characters through lexptr. */
1831 int saw_structop = last_was_structop;
1834 last_was_structop = 0;
1838 /* Check if this is a macro invocation that we need to expand. */
1839 if (! scanning_macro_expansion ())
1841 char *expanded = macro_expand_next (&lexptr,
1842 standard_macro_lookup,
1843 expression_macro_scope);
1846 scan_macro_expansion (expanded);
1849 prev_lexptr = lexptr;
1852 /* See if it is a special token of length 3. */
1853 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1854 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1856 if (tokentab3[i].cxx_only
1857 && parse_language->la_language != language_cplus)
1861 yylval.opcode = tokentab3[i].opcode;
1862 return tokentab3[i].token;
1865 /* See if it is a special token of length 2. */
1866 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1867 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1869 if (tokentab2[i].cxx_only
1870 && parse_language->la_language != language_cplus)
1874 yylval.opcode = tokentab2[i].opcode;
1875 if (in_parse_field && tokentab2[i].token == ARROW)
1876 last_was_structop = 1;
1877 return tokentab2[i].token;
1880 switch (c = *tokstart)
1883 /* If we were just scanning the result of a macro expansion,
1884 then we need to resume scanning the original text.
1885 If we're parsing for field name completion, and the previous
1886 token allows such completion, return a COMPLETE token.
1887 Otherwise, we were already scanning the original text, and
1888 we're really done. */
1889 if (scanning_macro_expansion ())
1891 finished_macro_expansion ();
1894 else if (saw_name_at_eof)
1896 saw_name_at_eof = 0;
1899 else if (saw_structop)
1918 if (paren_depth == 0)
1925 if (comma_terminates
1927 && ! scanning_macro_expansion ())
1933 /* Might be a floating point number. */
1934 if (lexptr[1] < '0' || lexptr[1] > '9')
1937 last_was_structop = 1;
1938 goto symbol; /* Nope, must be a symbol. */
1940 /* FALL THRU into number case. */
1953 /* It's a number. */
1954 int got_dot = 0, got_e = 0, toktype;
1956 int hex = input_radix > 10;
1958 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1963 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1971 /* This test includes !hex because 'e' is a valid hex digit
1972 and thus does not indicate a floating point number when
1973 the radix is hex. */
1974 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1975 got_dot = got_e = 1;
1976 /* This test does not include !hex, because a '.' always indicates
1977 a decimal floating point number regardless of the radix. */
1978 else if (!got_dot && *p == '.')
1980 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1981 && (*p == '-' || *p == '+'))
1982 /* This is the sign of the exponent, not the end of the
1985 /* We will take any letters or digits. parse_number will
1986 complain if past the radix, or if L or U are not final. */
1987 else if ((*p < '0' || *p > '9')
1988 && ((*p < 'a' || *p > 'z')
1989 && (*p < 'A' || *p > 'Z')))
1992 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1993 if (toktype == ERROR)
1995 char *err_copy = (char *) alloca (p - tokstart + 1);
1997 memcpy (err_copy, tokstart, p - tokstart);
1998 err_copy[p - tokstart] = 0;
1999 error ("Invalid number \"%s\".", err_copy);
2030 if (tokstart[1] != '"' && tokstart[1] != '\'')
2037 int result = parse_string_or_char (tokstart, &lexptr, &yylval.tsval,
2042 error ("Empty character constant.");
2043 else if (host_len > 2 && c == '\'')
2046 namelen = lexptr - tokstart - 1;
2049 else if (host_len > 1)
2050 error ("Invalid character constant.");
2056 if (!(c == '_' || c == '$'
2057 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
2058 /* We must have come across a bad character (e.g. ';'). */
2059 error ("Invalid character '%c' in expression.", c);
2061 /* It's a name. See how long it is. */
2063 for (c = tokstart[namelen];
2064 (c == '_' || c == '$' || (c >= '0' && c <= '9')
2065 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
2067 /* Template parameter lists are part of the name.
2068 FIXME: This mishandles `print $a<4&&$a>3'. */
2072 /* Scan ahead to get rest of the template specification. Note
2073 that we look ahead only when the '<' adjoins non-whitespace
2074 characters; for comparison expressions, e.g. "a < b > c",
2075 there must be spaces before the '<', etc. */
2077 char * p = find_template_name_end (tokstart + namelen);
2079 namelen = p - tokstart;
2082 c = tokstart[++namelen];
2085 /* The token "if" terminates the expression and is NOT removed from
2086 the input stream. It doesn't count if it appears in the
2087 expansion of a macro. */
2089 && tokstart[0] == 'i'
2090 && tokstart[1] == 'f'
2091 && ! scanning_macro_expansion ())
2100 yylval.sval.ptr = tokstart;
2101 yylval.sval.length = namelen;
2103 /* Catch specific keywords. */
2104 copy = copy_name (yylval.sval);
2105 for (i = 0; i < sizeof ident_tokens / sizeof ident_tokens[0]; i++)
2106 if (strcmp (copy, ident_tokens[i].operator) == 0)
2108 if (ident_tokens[i].cxx_only
2109 && parse_language->la_language != language_cplus)
2112 /* It is ok to always set this, even though we don't always
2113 strictly need to. */
2114 yylval.opcode = ident_tokens[i].opcode;
2115 return ident_tokens[i].token;
2118 if (*tokstart == '$')
2120 write_dollar_variable (yylval.sval);
2124 /* Use token-type BLOCKNAME for symbols that happen to be defined as
2125 functions or symtabs. If this is not so, then ...
2126 Use token-type TYPENAME for symbols that happen to be defined
2127 currently as names of types; NAME for other symbols.
2128 The caller is not constrained to care about the distinction. */
2131 int is_a_field_of_this = 0;
2134 sym = lookup_symbol (copy, expression_context_block,
2136 parse_language->la_language == language_cplus
2137 ? &is_a_field_of_this : (int *) NULL);
2138 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
2139 no psymtabs (coff, xcoff, or some future change to blow away the
2140 psymtabs once once symbols are read). */
2141 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
2143 yylval.ssym.sym = sym;
2144 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2148 { /* See if it's a file name. */
2149 struct symtab *symtab;
2151 symtab = lookup_symtab (copy);
2155 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
2160 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
2162 /* NOTE: carlton/2003-09-25: There used to be code here to
2163 handle nested types. It didn't work very well. See the
2164 comment before qualified_type for more info. */
2165 yylval.tsym.type = SYMBOL_TYPE (sym);
2169 = language_lookup_primitive_type_by_name (parse_language,
2170 parse_gdbarch, copy);
2171 if (yylval.tsym.type != NULL)
2174 /* Input names that aren't symbols but ARE valid hex numbers,
2175 when the input radix permits them, can be names or numbers
2176 depending on the parse. Note we support radixes > 16 here. */
2178 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
2179 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
2181 YYSTYPE newlval; /* Its value is ignored. */
2182 hextype = parse_number (tokstart, namelen, 0, &newlval);
2185 yylval.ssym.sym = sym;
2186 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2191 /* Any other kind of symbol */
2192 yylval.ssym.sym = sym;
2193 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
2194 if (in_parse_field && *lexptr == '\0')
2195 saw_name_at_eof = 1;
2204 struct cleanup *back_to = make_cleanup (free_current_contents,
2205 &expression_macro_scope);
2207 /* Set up the scope for macro expansion. */
2208 expression_macro_scope = NULL;
2210 if (expression_context_block)
2211 expression_macro_scope
2212 = sal_macro_scope (find_pc_line (expression_context_pc, 0));
2214 expression_macro_scope = default_macro_scope ();
2215 if (! expression_macro_scope)
2216 expression_macro_scope = user_macro_scope ();
2218 /* Initialize macro expansion code. */
2219 obstack_init (&expansion_obstack);
2220 gdb_assert (! macro_original_text);
2221 make_cleanup (scan_macro_cleanup, 0);
2223 /* Initialize some state used by the lexer. */
2224 last_was_structop = 0;
2225 saw_name_at_eof = 0;
2227 result = yyparse ();
2228 do_cleanups (back_to);
2237 lexptr = prev_lexptr;
2239 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);