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
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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* Parse a C expression from text in a string,
24 and return the result as a struct expression pointer.
25 That structure contains arithmetic operations in reverse polish,
26 with constants represented by operations that are followed by special data.
27 See expression.h for the details of the format.
28 What is important here is that it can be built up sequentially
29 during the process of parsing; the lower levels of the tree always
30 come first in the result.
32 Note that malloc's and realloc's in this file are transformed to
33 xmalloc and xrealloc respectively by the same sed command in the
34 makefile that remaps any other malloc/realloc inserted by the parser
35 generator. Doing this with #defines and trying to control the interaction
36 with include files (<malloc.h> and <stdlib.h> for example) just became
37 too messy, particularly when such includes can be inserted at random
38 times by the parser generator. */
43 #include "gdb_string.h"
45 #include "expression.h"
47 #include "parser-defs.h"
50 #include "bfd.h" /* Required by objfiles.h. */
51 #include "symfile.h" /* Required by objfiles.h. */
52 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
55 #include "cp-support.h"
58 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
59 as well as gratuitiously global symbol names, so we can have multiple
60 yacc generated parsers in gdb. Note that these are only the variables
61 produced by yacc. If other parser generators (bison, byacc, etc) produce
62 additional global names that conflict at link time, then those parser
63 generators need to be fixed instead of adding those names to this list. */
65 #define yymaxdepth c_maxdepth
66 #define yyparse c_parse_internal
68 #define yyerror c_error
71 #define yydebug c_debug
80 #define yyerrflag c_errflag
81 #define yynerrs c_nerrs
86 #define yystate c_state
92 #define yyreds c_reds /* With YYDEBUG defined */
93 #define yytoks c_toks /* With YYDEBUG defined */
94 #define yyname c_name /* With YYDEBUG defined */
95 #define yyrule c_rule /* With YYDEBUG defined */
98 #define yydefred c_yydefred
99 #define yydgoto c_yydgoto
100 #define yysindex c_yysindex
101 #define yyrindex c_yyrindex
102 #define yygindex c_yygindex
103 #define yytable c_yytable
104 #define yycheck c_yycheck
107 #define YYDEBUG 1 /* Default to yydebug support */
110 #define YYFPRINTF parser_fprintf
114 static int yylex (void);
116 void yyerror (char *);
120 /* Although the yacc "value" of an expression is not used,
121 since the result is stored in the structure being created,
122 other node types do have values. */
138 } typed_val_decfloat;
143 struct symtoken ssym;
146 enum exp_opcode opcode;
147 struct internalvar *ivar;
154 /* YYSTYPE gets defined by %union */
155 static int parse_number (char *, int, int, YYSTYPE *);
158 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
160 %type <tval> type typebase qualified_type
161 %type <tvec> nonempty_typelist
162 /* %type <bval> block */
164 /* Fancy type parsing. */
165 %type <voidval> func_mod direct_abs_decl abs_decl
167 %type <lval> array_mod
169 %token <typed_val_int> INT
170 %token <typed_val_float> FLOAT
171 %token <typed_val_decfloat> DECFLOAT
173 /* Both NAME and TYPENAME tokens represent symbols in the input,
174 and both convey their data as strings.
175 But a TYPENAME is a string that happens to be defined as a typedef
176 or builtin type name (such as int or char)
177 and a NAME is any other symbol.
178 Contexts where this distinction is not important can use the
179 nonterminal "name", which matches either NAME or TYPENAME. */
182 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
183 %token <voidval> COMPLETE
184 %token <tsym> TYPENAME
186 %type <ssym> name_not_typename
187 %type <tsym> typename
189 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
190 but which would parse as a valid number in the current input radix.
191 E.g. "c" when input_radix==16. Depending on the parse, it will be
192 turned into a name or into a number. */
194 %token <ssym> NAME_OR_INT
196 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
200 /* Special type cases, put in to allow the parser to distinguish different
202 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
204 %token <voidval> VARIABLE
206 %token <opcode> ASSIGN_MODIFY
215 %right '=' ASSIGN_MODIFY
223 %left '<' '>' LEQ GEQ
228 %right UNARY INCREMENT DECREMENT
229 %right ARROW '.' '[' '('
230 %token <ssym> BLOCKNAME
231 %token <bval> FILENAME
243 { write_exp_elt_opcode(OP_TYPE);
244 write_exp_elt_type($1);
245 write_exp_elt_opcode(OP_TYPE);}
248 /* Expressions, including the comma operator. */
251 { write_exp_elt_opcode (BINOP_COMMA); }
254 /* Expressions, not including the comma operator. */
255 exp : '*' exp %prec UNARY
256 { write_exp_elt_opcode (UNOP_IND); }
259 exp : '&' exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_ADDR); }
263 exp : '-' exp %prec UNARY
264 { write_exp_elt_opcode (UNOP_NEG); }
267 exp : '+' exp %prec UNARY
268 { write_exp_elt_opcode (UNOP_PLUS); }
271 exp : '!' exp %prec UNARY
272 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
275 exp : '~' exp %prec UNARY
276 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
279 exp : INCREMENT exp %prec UNARY
280 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
283 exp : DECREMENT exp %prec UNARY
284 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
287 exp : exp INCREMENT %prec UNARY
288 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
291 exp : exp DECREMENT %prec UNARY
292 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
295 exp : SIZEOF exp %prec UNARY
296 { write_exp_elt_opcode (UNOP_SIZEOF); }
300 { write_exp_elt_opcode (STRUCTOP_PTR);
301 write_exp_string ($3);
302 write_exp_elt_opcode (STRUCTOP_PTR); }
305 exp : exp ARROW name COMPLETE
306 { mark_struct_expression ();
307 write_exp_elt_opcode (STRUCTOP_PTR);
308 write_exp_string ($3);
309 write_exp_elt_opcode (STRUCTOP_PTR); }
312 exp : exp ARROW COMPLETE
314 mark_struct_expression ();
315 write_exp_elt_opcode (STRUCTOP_PTR);
318 write_exp_string (s);
319 write_exp_elt_opcode (STRUCTOP_PTR); }
322 exp : exp ARROW qualified_name
323 { /* exp->type::name becomes exp->*(&type::name) */
324 /* Note: this doesn't work if name is a
325 static member! FIXME */
326 write_exp_elt_opcode (UNOP_ADDR);
327 write_exp_elt_opcode (STRUCTOP_MPTR); }
330 exp : exp ARROW '*' exp
331 { write_exp_elt_opcode (STRUCTOP_MPTR); }
335 { write_exp_elt_opcode (STRUCTOP_STRUCT);
336 write_exp_string ($3);
337 write_exp_elt_opcode (STRUCTOP_STRUCT); }
340 exp : exp '.' name COMPLETE
341 { mark_struct_expression ();
342 write_exp_elt_opcode (STRUCTOP_STRUCT);
343 write_exp_string ($3);
344 write_exp_elt_opcode (STRUCTOP_STRUCT); }
347 exp : exp '.' COMPLETE
349 mark_struct_expression ();
350 write_exp_elt_opcode (STRUCTOP_STRUCT);
353 write_exp_string (s);
354 write_exp_elt_opcode (STRUCTOP_STRUCT); }
357 exp : exp '.' qualified_name
358 { /* exp.type::name becomes exp.*(&type::name) */
359 /* Note: this doesn't work if name is a
360 static member! FIXME */
361 write_exp_elt_opcode (UNOP_ADDR);
362 write_exp_elt_opcode (STRUCTOP_MEMBER); }
365 exp : exp '.' '*' exp
366 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
369 exp : exp '[' exp1 ']'
370 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
374 /* This is to save the value of arglist_len
375 being accumulated by an outer function call. */
376 { start_arglist (); }
377 arglist ')' %prec ARROW
378 { write_exp_elt_opcode (OP_FUNCALL);
379 write_exp_elt_longcst ((LONGEST) end_arglist ());
380 write_exp_elt_opcode (OP_FUNCALL); }
384 { start_arglist (); }
394 arglist : arglist ',' exp %prec ABOVE_COMMA
399 { $$ = end_arglist () - 1; }
401 exp : lcurly arglist rcurly %prec ARROW
402 { write_exp_elt_opcode (OP_ARRAY);
403 write_exp_elt_longcst ((LONGEST) 0);
404 write_exp_elt_longcst ((LONGEST) $3);
405 write_exp_elt_opcode (OP_ARRAY); }
408 exp : lcurly type rcurly exp %prec UNARY
409 { write_exp_elt_opcode (UNOP_MEMVAL);
410 write_exp_elt_type ($2);
411 write_exp_elt_opcode (UNOP_MEMVAL); }
414 exp : '(' type ')' exp %prec UNARY
415 { write_exp_elt_opcode (UNOP_CAST);
416 write_exp_elt_type ($2);
417 write_exp_elt_opcode (UNOP_CAST); }
424 /* Binary operators in order of decreasing precedence. */
427 { write_exp_elt_opcode (BINOP_REPEAT); }
431 { write_exp_elt_opcode (BINOP_MUL); }
435 { write_exp_elt_opcode (BINOP_DIV); }
439 { write_exp_elt_opcode (BINOP_REM); }
443 { write_exp_elt_opcode (BINOP_ADD); }
447 { write_exp_elt_opcode (BINOP_SUB); }
451 { write_exp_elt_opcode (BINOP_LSH); }
455 { write_exp_elt_opcode (BINOP_RSH); }
459 { write_exp_elt_opcode (BINOP_EQUAL); }
462 exp : exp NOTEQUAL exp
463 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
467 { write_exp_elt_opcode (BINOP_LEQ); }
471 { write_exp_elt_opcode (BINOP_GEQ); }
475 { write_exp_elt_opcode (BINOP_LESS); }
479 { write_exp_elt_opcode (BINOP_GTR); }
483 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
487 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
491 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
495 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
499 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
502 exp : exp '?' exp ':' exp %prec '?'
503 { write_exp_elt_opcode (TERNOP_COND); }
507 { write_exp_elt_opcode (BINOP_ASSIGN); }
510 exp : exp ASSIGN_MODIFY exp
511 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
512 write_exp_elt_opcode ($2);
513 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
517 { write_exp_elt_opcode (OP_LONG);
518 write_exp_elt_type ($1.type);
519 write_exp_elt_longcst ((LONGEST)($1.val));
520 write_exp_elt_opcode (OP_LONG); }
525 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
526 write_exp_elt_opcode (OP_LONG);
527 write_exp_elt_type (val.typed_val_int.type);
528 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
529 write_exp_elt_opcode (OP_LONG);
535 { write_exp_elt_opcode (OP_DOUBLE);
536 write_exp_elt_type ($1.type);
537 write_exp_elt_dblcst ($1.dval);
538 write_exp_elt_opcode (OP_DOUBLE); }
542 { write_exp_elt_opcode (OP_DECFLOAT);
543 write_exp_elt_type ($1.type);
544 write_exp_elt_decfloatcst ($1.val);
545 write_exp_elt_opcode (OP_DECFLOAT); }
552 /* Already written by write_dollar_variable. */
555 exp : SIZEOF '(' type ')' %prec UNARY
556 { write_exp_elt_opcode (OP_LONG);
557 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_int);
559 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
560 write_exp_elt_opcode (OP_LONG); }
564 { /* C strings are converted into array constants with
565 an explicit null byte added at the end. Thus
566 the array upper bound is the string length.
567 There is no such thing in C as a completely empty
569 char *sp = $1.ptr; int count = $1.length;
572 write_exp_elt_opcode (OP_LONG);
573 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
574 write_exp_elt_longcst ((LONGEST)(*sp++));
575 write_exp_elt_opcode (OP_LONG);
577 write_exp_elt_opcode (OP_LONG);
578 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
579 write_exp_elt_longcst ((LONGEST)'\0');
580 write_exp_elt_opcode (OP_LONG);
581 write_exp_elt_opcode (OP_ARRAY);
582 write_exp_elt_longcst ((LONGEST) 0);
583 write_exp_elt_longcst ((LONGEST) ($1.length));
584 write_exp_elt_opcode (OP_ARRAY); }
589 { write_exp_elt_opcode (OP_LONG);
590 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
591 write_exp_elt_longcst ((LONGEST) 1);
592 write_exp_elt_opcode (OP_LONG); }
596 { write_exp_elt_opcode (OP_LONG);
597 write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
598 write_exp_elt_longcst ((LONGEST) 0);
599 write_exp_elt_opcode (OP_LONG); }
607 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
609 error ("No file or function \"%s\".",
610 copy_name ($1.stoken));
618 block : block COLONCOLON name
620 = lookup_symbol (copy_name ($3), $1,
621 VAR_DOMAIN, (int *) NULL);
622 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
623 error ("No function \"%s\" in specified context.",
625 $$ = SYMBOL_BLOCK_VALUE (tem); }
628 variable: block COLONCOLON name
629 { struct symbol *sym;
630 sym = lookup_symbol (copy_name ($3), $1,
631 VAR_DOMAIN, (int *) NULL);
633 error ("No symbol \"%s\" in specified context.",
636 write_exp_elt_opcode (OP_VAR_VALUE);
637 /* block_found is set by lookup_symbol. */
638 write_exp_elt_block (block_found);
639 write_exp_elt_sym (sym);
640 write_exp_elt_opcode (OP_VAR_VALUE); }
643 qualified_name: typebase COLONCOLON name
645 struct type *type = $1;
646 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
647 && TYPE_CODE (type) != TYPE_CODE_UNION
648 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
649 error ("`%s' is not defined as an aggregate type.",
652 write_exp_elt_opcode (OP_SCOPE);
653 write_exp_elt_type (type);
654 write_exp_string ($3);
655 write_exp_elt_opcode (OP_SCOPE);
657 | typebase COLONCOLON '~' name
659 struct type *type = $1;
660 struct stoken tmp_token;
661 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
662 && TYPE_CODE (type) != TYPE_CODE_UNION
663 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
664 error ("`%s' is not defined as an aggregate type.",
667 tmp_token.ptr = (char*) alloca ($4.length + 2);
668 tmp_token.length = $4.length + 1;
669 tmp_token.ptr[0] = '~';
670 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
671 tmp_token.ptr[tmp_token.length] = 0;
673 /* Check for valid destructor name. */
674 destructor_name_p (tmp_token.ptr, type);
675 write_exp_elt_opcode (OP_SCOPE);
676 write_exp_elt_type (type);
677 write_exp_string (tmp_token);
678 write_exp_elt_opcode (OP_SCOPE);
682 variable: qualified_name
685 char *name = copy_name ($2);
687 struct minimal_symbol *msymbol;
690 lookup_symbol (name, (const struct block *) NULL,
691 VAR_DOMAIN, (int *) NULL);
694 write_exp_elt_opcode (OP_VAR_VALUE);
695 write_exp_elt_block (NULL);
696 write_exp_elt_sym (sym);
697 write_exp_elt_opcode (OP_VAR_VALUE);
701 msymbol = lookup_minimal_symbol (name, NULL, NULL);
704 write_exp_msymbol (msymbol,
705 lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
706 builtin_type (current_gdbarch)->builtin_int);
709 if (!have_full_symbols () && !have_partial_symbols ())
710 error ("No symbol table is loaded. Use the \"file\" command.");
712 error ("No symbol \"%s\" in current context.", name);
716 variable: name_not_typename
717 { struct symbol *sym = $1.sym;
721 if (symbol_read_needs_frame (sym))
723 if (innermost_block == 0 ||
724 contained_in (block_found,
726 innermost_block = block_found;
729 write_exp_elt_opcode (OP_VAR_VALUE);
730 /* We want to use the selected frame, not
731 another more inner frame which happens to
732 be in the same block. */
733 write_exp_elt_block (NULL);
734 write_exp_elt_sym (sym);
735 write_exp_elt_opcode (OP_VAR_VALUE);
737 else if ($1.is_a_field_of_this)
739 /* C++: it hangs off of `this'. Must
740 not inadvertently convert from a method call
742 if (innermost_block == 0 ||
743 contained_in (block_found, innermost_block))
744 innermost_block = block_found;
745 write_exp_elt_opcode (OP_THIS);
746 write_exp_elt_opcode (OP_THIS);
747 write_exp_elt_opcode (STRUCTOP_PTR);
748 write_exp_string ($1.stoken);
749 write_exp_elt_opcode (STRUCTOP_PTR);
753 struct minimal_symbol *msymbol;
754 char *arg = copy_name ($1.stoken);
757 lookup_minimal_symbol (arg, NULL, NULL);
760 write_exp_msymbol (msymbol,
761 lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
762 builtin_type (current_gdbarch)->builtin_int);
764 else if (!have_full_symbols () && !have_partial_symbols ())
765 error ("No symbol table is loaded. Use the \"file\" command.");
767 error ("No symbol \"%s\" in current context.",
768 copy_name ($1.stoken));
773 space_identifier : '@' NAME
774 { push_type_address_space (copy_name ($2.stoken));
775 push_type (tp_space_identifier);
779 const_or_volatile: const_or_volatile_noopt
783 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
786 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
787 | const_or_volatile_noopt
790 const_or_volatile_or_space_identifier:
791 const_or_volatile_or_space_identifier_noopt
796 { push_type (tp_pointer); $$ = 0; }
798 { push_type (tp_pointer); $$ = $2; }
800 { push_type (tp_reference); $$ = 0; }
802 { push_type (tp_reference); $$ = $2; }
806 direct_abs_decl: '(' abs_decl ')'
808 | direct_abs_decl array_mod
811 push_type (tp_array);
816 push_type (tp_array);
820 | direct_abs_decl func_mod
821 { push_type (tp_function); }
823 { push_type (tp_function); }
834 | '(' nonempty_typelist ')'
835 { free ($2); $$ = 0; }
838 /* We used to try to recognize pointer to member types here, but
839 that didn't work (shift/reduce conflicts meant that these rules never
840 got executed). The problem is that
841 int (foo::bar::baz::bizzle)
842 is a function type but
843 int (foo::bar::baz::bizzle::*)
844 is a pointer to member type. Stroustrup loses again! */
849 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
853 { $$ = builtin_type (current_gdbarch)->builtin_int; }
855 { $$ = builtin_type (current_gdbarch)->builtin_long; }
857 { $$ = builtin_type (current_gdbarch)->builtin_short; }
859 { $$ = builtin_type (current_gdbarch)->builtin_long; }
860 | LONG SIGNED_KEYWORD INT_KEYWORD
861 { $$ = builtin_type (current_gdbarch)->builtin_long; }
862 | LONG SIGNED_KEYWORD
863 { $$ = builtin_type (current_gdbarch)->builtin_long; }
864 | SIGNED_KEYWORD LONG INT_KEYWORD
865 { $$ = builtin_type (current_gdbarch)->builtin_long; }
866 | UNSIGNED LONG INT_KEYWORD
867 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
868 | LONG UNSIGNED INT_KEYWORD
869 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
871 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
873 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
874 | LONG LONG INT_KEYWORD
875 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
876 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
877 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
878 | LONG LONG SIGNED_KEYWORD
879 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
880 | SIGNED_KEYWORD LONG LONG
881 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
882 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
883 { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
885 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
886 | UNSIGNED LONG LONG INT_KEYWORD
887 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
889 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
890 | LONG LONG UNSIGNED INT_KEYWORD
891 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
893 { $$ = builtin_type (current_gdbarch)->builtin_short; }
894 | SHORT SIGNED_KEYWORD INT_KEYWORD
895 { $$ = builtin_type (current_gdbarch)->builtin_short; }
896 | SHORT SIGNED_KEYWORD
897 { $$ = builtin_type (current_gdbarch)->builtin_short; }
898 | UNSIGNED SHORT INT_KEYWORD
899 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
901 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
902 | SHORT UNSIGNED INT_KEYWORD
903 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
905 { $$ = builtin_type (current_gdbarch)->builtin_double; }
906 | LONG DOUBLE_KEYWORD
907 { $$ = builtin_type (current_gdbarch)->builtin_long_double; }
909 { $$ = lookup_struct (copy_name ($2),
910 expression_context_block); }
912 { $$ = lookup_struct (copy_name ($2),
913 expression_context_block); }
915 { $$ = lookup_union (copy_name ($2),
916 expression_context_block); }
918 { $$ = lookup_enum (copy_name ($2),
919 expression_context_block); }
921 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
923 { $$ = builtin_type (current_gdbarch)->builtin_unsigned_int; }
924 | SIGNED_KEYWORD typename
925 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
927 { $$ = builtin_type (current_gdbarch)->builtin_int; }
928 /* It appears that this rule for templates is never
929 reduced; template recognition happens by lookahead
930 in the token processing code in yylex. */
931 | TEMPLATE name '<' type '>'
932 { $$ = lookup_template_type(copy_name($2), $4,
933 expression_context_block);
935 | const_or_volatile_or_space_identifier_noopt typebase
936 { $$ = follow_types ($2); }
937 | typebase const_or_volatile_or_space_identifier_noopt
938 { $$ = follow_types ($1); }
942 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
943 reduce-reduce conflicts, because the parser doesn't know whether or
944 not to use qualified_name or qualified_type: the rules are
945 identical. If the parser is parsing 'A::B::x', then, when it sees
946 the second '::', it knows that the expression to the left of it has
947 to be a type, so it uses qualified_type. But if it is parsing just
948 'A::B', then it doesn't have any way of knowing which rule to use,
949 so there's a reduce-reduce conflict; it picks qualified_name, since
950 that occurs earlier in this file than qualified_type.
952 There's no good way to fix this with the grammar as it stands; as
953 far as I can tell, some of the problems arise from ambiguities that
954 GDB introduces ('start' can be either an expression or a type), but
955 some of it is inherent to the nature of C++ (you want to treat the
956 input "(FOO)" fairly differently depending on whether FOO is an
957 expression or a type, and if FOO is a complex expression, this can
958 be hard to determine at the right time). Fortunately, it works
959 pretty well in most cases. For example, if you do 'ptype A::B',
960 where A::B is a nested type, then the parser will mistakenly
961 misidentify it as an expression; but evaluate_subexp will get
962 called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
963 will work out anyways. But there are situations where the parser
964 will get confused: the most common one that I've run into is when
969 where the parser doesn't realize that A::B has to be a type until
970 it hits the first right paren, at which point it's too late. (The
971 workaround is to type "print *(('A::B' *) x)" instead.) (And
972 another solution is to fix our symbol-handling code so that the
973 user never wants to type something like that in the first place,
974 because we get all the types right without the user's help!)
976 Perhaps we could fix this by making the lexer smarter. Some of
977 this functionality used to be in the lexer, but in a way that
978 worked even less well than the current solution: that attempt
979 involved having the parser sometimes handle '::' and having the
980 lexer sometimes handle it, and without a clear division of
981 responsibility, it quickly degenerated into a big mess. Probably
982 the eventual correct solution will give more of a role to the lexer
983 (ideally via code that is shared between the lexer and
984 decode_line_1), but I'm not holding my breath waiting for somebody
985 to get around to cleaning this up... */
987 qualified_type: typebase COLONCOLON name
989 struct type *type = $1;
990 struct type *new_type;
991 char *ncopy = alloca ($3.length + 1);
993 memcpy (ncopy, $3.ptr, $3.length);
994 ncopy[$3.length] = '\0';
996 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
997 && TYPE_CODE (type) != TYPE_CODE_UNION
998 && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
999 error ("`%s' is not defined as an aggregate type.",
1002 new_type = cp_lookup_nested_type (type, ncopy,
1003 expression_context_block);
1004 if (new_type == NULL)
1005 error ("No type \"%s\" within class or namespace \"%s\".",
1006 ncopy, TYPE_NAME (type));
1015 $$.stoken.ptr = "int";
1016 $$.stoken.length = 3;
1017 $$.type = builtin_type (current_gdbarch)->builtin_int;
1021 $$.stoken.ptr = "long";
1022 $$.stoken.length = 4;
1023 $$.type = builtin_type (current_gdbarch)->builtin_long;
1027 $$.stoken.ptr = "short";
1028 $$.stoken.length = 5;
1029 $$.type = builtin_type (current_gdbarch)->builtin_short;
1035 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
1036 $<ivec>$[0] = 1; /* Number of types in vector */
1039 | nonempty_typelist ',' type
1040 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
1041 $$ = (struct type **) realloc ((char *) $1, len);
1042 $$[$<ivec>$[0]] = $3;
1047 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1048 { $$ = follow_types ($1); }
1051 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
1052 | VOLATILE_KEYWORD CONST_KEYWORD
1055 const_or_volatile_noopt: const_and_volatile
1056 { push_type (tp_const);
1057 push_type (tp_volatile);
1060 { push_type (tp_const); }
1062 { push_type (tp_volatile); }
1065 name : NAME { $$ = $1.stoken; }
1066 | BLOCKNAME { $$ = $1.stoken; }
1067 | TYPENAME { $$ = $1.stoken; }
1068 | NAME_OR_INT { $$ = $1.stoken; }
1071 name_not_typename : NAME
1073 /* These would be useful if name_not_typename was useful, but it is just
1074 a fake for "variable", so these cause reduce/reduce conflicts because
1075 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1076 =exp) or just an exp. If name_not_typename was ever used in an lvalue
1077 context where only a name could occur, this might be useful.
1084 /* Take care of parsing a number (anything that starts with a digit).
1085 Set yylval and return the token type; update lexptr.
1086 LEN is the number of characters in it. */
1088 /*** Needs some error checking for the float case ***/
1091 parse_number (p, len, parsed_float, putithere)
1097 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
1098 here, and we do kind of silly things like cast to unsigned. */
1105 int base = input_radix;
1108 /* Number of "L" suffixes encountered. */
1111 /* We have found a "L" or "U" suffix. */
1112 int found_suffix = 0;
1115 struct type *signed_type;
1116 struct type *unsigned_type;
1120 /* It's a float since it contains a point or an exponent. */
1121 char *s = malloc (len);
1122 int num = 0; /* number of tokens scanned by scanf */
1123 char saved_char = p[len];
1125 p[len] = 0; /* null-terminate the token */
1127 /* If it ends at "df", "dd" or "dl", take it as type of decimal floating
1128 point. Return DECFLOAT. */
1130 if (p[len - 2] == 'd' && p[len - 1] == 'f')
1133 putithere->typed_val_decfloat.type
1134 = builtin_type (current_gdbarch)->builtin_decfloat;
1135 decimal_from_string (putithere->typed_val_decfloat.val, 4, p);
1136 p[len] = saved_char;
1140 if (p[len - 2] == 'd' && p[len - 1] == 'd')
1143 putithere->typed_val_decfloat.type
1144 = builtin_type (current_gdbarch)->builtin_decdouble;
1145 decimal_from_string (putithere->typed_val_decfloat.val, 8, p);
1146 p[len] = saved_char;
1150 if (p[len - 2] == 'd' && p[len - 1] == 'l')
1153 putithere->typed_val_decfloat.type
1154 = builtin_type (current_gdbarch)->builtin_declong;
1155 decimal_from_string (putithere->typed_val_decfloat.val, 16, p);
1156 p[len] = saved_char;
1160 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%s",
1161 &putithere->typed_val_float.dval, s);
1162 p[len] = saved_char; /* restore the input stream */
1165 putithere->typed_val_float.type =
1166 builtin_type (current_gdbarch)->builtin_double;
1170 /* See if it has any float suffix: 'f' for float, 'l' for long
1172 if (!strcasecmp (s, "f"))
1173 putithere->typed_val_float.type =
1174 builtin_type (current_gdbarch)->builtin_float;
1175 else if (!strcasecmp (s, "l"))
1176 putithere->typed_val_float.type =
1177 builtin_type (current_gdbarch)->builtin_long_double;
1189 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1223 if (c >= 'A' && c <= 'Z')
1225 if (c != 'l' && c != 'u')
1227 if (c >= '0' && c <= '9')
1235 if (base > 10 && c >= 'a' && c <= 'f')
1239 n += i = c - 'a' + 10;
1252 return ERROR; /* Char not a digit */
1255 return ERROR; /* Invalid digit in this base */
1257 /* Portably test for overflow (only works for nonzero values, so make
1258 a second check for zero). FIXME: Can't we just make n and prevn
1259 unsigned and avoid this? */
1260 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1261 unsigned_p = 1; /* Try something unsigned */
1263 /* Portably test for unsigned overflow.
1264 FIXME: This check is wrong; for example it doesn't find overflow
1265 on 0x123456789 when LONGEST is 32 bits. */
1266 if (c != 'l' && c != 'u' && n != 0)
1268 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1269 error ("Numeric constant too large.");
1274 /* An integer constant is an int, a long, or a long long. An L
1275 suffix forces it to be long; an LL suffix forces it to be long
1276 long. If not forced to a larger size, it gets the first type of
1277 the above that it fits in. To figure out whether it fits, we
1278 shift it right and see whether anything remains. Note that we
1279 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1280 operation, because many compilers will warn about such a shift
1281 (which always produces a zero result). Sometimes gdbarch_int_bit
1282 or gdbarch_long_bit will be that big, sometimes not. To deal with
1283 the case where it is we just always shift the value more than
1284 once, with fewer bits each time. */
1286 un = (ULONGEST)n >> 2;
1288 && (un >> (gdbarch_int_bit (current_gdbarch) - 2)) == 0)
1290 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (current_gdbarch) - 1);
1292 /* A large decimal (not hex or octal) constant (between INT_MAX
1293 and UINT_MAX) is a long or unsigned long, according to ANSI,
1294 never an unsigned int, but this code treats it as unsigned
1295 int. This probably should be fixed. GCC gives a warning on
1298 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_int;
1299 signed_type = builtin_type (current_gdbarch)->builtin_int;
1301 else if (long_p <= 1
1302 && (un >> (gdbarch_long_bit (current_gdbarch) - 2)) == 0)
1304 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (current_gdbarch) - 1);
1305 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long;
1306 signed_type = builtin_type (current_gdbarch)->builtin_long;
1311 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1312 < gdbarch_long_long_bit (current_gdbarch))
1313 /* A long long does not fit in a LONGEST. */
1314 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1316 shift = (gdbarch_long_long_bit (current_gdbarch) - 1);
1317 high_bit = (ULONGEST) 1 << shift;
1318 unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long_long;
1319 signed_type = builtin_type (current_gdbarch)->builtin_long_long;
1322 putithere->typed_val_int.val = n;
1324 /* If the high bit of the worked out type is set then this number
1325 has to be unsigned. */
1327 if (unsigned_p || (n & high_bit))
1329 putithere->typed_val_int.type = unsigned_type;
1333 putithere->typed_val_int.type = signed_type;
1343 enum exp_opcode opcode;
1346 static const struct token tokentab3[] =
1348 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1349 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1352 static const struct token tokentab2[] =
1354 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1355 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1356 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1357 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1358 {"%=", ASSIGN_MODIFY, BINOP_REM},
1359 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1360 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1361 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1362 {"++", INCREMENT, BINOP_END},
1363 {"--", DECREMENT, BINOP_END},
1364 {"->", ARROW, BINOP_END},
1365 {"&&", ANDAND, BINOP_END},
1366 {"||", OROR, BINOP_END},
1367 {"::", COLONCOLON, BINOP_END},
1368 {"<<", LSH, BINOP_END},
1369 {">>", RSH, BINOP_END},
1370 {"==", EQUAL, BINOP_END},
1371 {"!=", NOTEQUAL, BINOP_END},
1372 {"<=", LEQ, BINOP_END},
1373 {">=", GEQ, BINOP_END}
1376 /* This is set if a NAME token appeared at the very end of the input
1377 string, with no whitespace separating the name from the EOF. This
1378 is used only when parsing to do field name completion. */
1379 static int saw_name_at_eof;
1381 /* This is set if the previously-returned token was a structure
1382 operator -- either '.' or ARROW. This is used only when parsing to
1383 do field name completion. */
1384 static int last_was_structop;
1386 /* Read one token, getting characters through lexptr. */
1397 static char *tempbuf;
1398 static int tempbufsize;
1399 char * token_string = NULL;
1400 int class_prefix = 0;
1401 int saw_structop = last_was_structop;
1403 last_was_structop = 0;
1407 /* Check if this is a macro invocation that we need to expand. */
1408 if (! scanning_macro_expansion ())
1410 char *expanded = macro_expand_next (&lexptr,
1411 expression_macro_lookup_func,
1412 expression_macro_lookup_baton);
1415 scan_macro_expansion (expanded);
1418 prev_lexptr = lexptr;
1421 /* See if it is a special token of length 3. */
1422 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1423 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1426 yylval.opcode = tokentab3[i].opcode;
1427 return tokentab3[i].token;
1430 /* See if it is a special token of length 2. */
1431 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1432 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1435 yylval.opcode = tokentab2[i].opcode;
1436 if (in_parse_field && tokentab2[i].opcode == ARROW)
1437 last_was_structop = 1;
1438 return tokentab2[i].token;
1441 switch (c = *tokstart)
1444 /* If we were just scanning the result of a macro expansion,
1445 then we need to resume scanning the original text.
1446 If we're parsing for field name completion, and the previous
1447 token allows such completion, return a COMPLETE token.
1448 Otherwise, we were already scanning the original text, and
1449 we're really done. */
1450 if (scanning_macro_expansion ())
1452 finished_macro_expansion ();
1455 else if (saw_name_at_eof)
1457 saw_name_at_eof = 0;
1460 else if (saw_structop)
1472 /* We either have a character constant ('0' or '\177' for example)
1473 or we have a quoted symbol reference ('foo(int,int)' in C++
1478 c = parse_escape (&lexptr);
1480 error ("Empty character constant.");
1481 else if (! host_char_to_target (c, &c))
1483 int toklen = lexptr - tokstart + 1;
1484 char *tok = alloca (toklen + 1);
1485 memcpy (tok, tokstart, toklen);
1487 error ("There is no character corresponding to %s in the target "
1488 "character set `%s'.", tok, target_charset ());
1491 yylval.typed_val_int.val = c;
1492 yylval.typed_val_int.type = builtin_type (current_gdbarch)->builtin_char;
1497 namelen = skip_quoted (tokstart) - tokstart;
1500 lexptr = tokstart + namelen;
1501 if (lexptr[-1] != '\'')
1502 error ("Unmatched single quote.");
1507 error ("Invalid character constant.");
1517 if (paren_depth == 0)
1524 if (comma_terminates
1526 && ! scanning_macro_expansion ())
1532 /* Might be a floating point number. */
1533 if (lexptr[1] < '0' || lexptr[1] > '9')
1536 last_was_structop = 1;
1537 goto symbol; /* Nope, must be a symbol. */
1539 /* FALL THRU into number case. */
1552 /* It's a number. */
1553 int got_dot = 0, got_e = 0, toktype;
1555 int hex = input_radix > 10;
1557 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1562 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1570 /* This test includes !hex because 'e' is a valid hex digit
1571 and thus does not indicate a floating point number when
1572 the radix is hex. */
1573 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1574 got_dot = got_e = 1;
1575 /* This test does not include !hex, because a '.' always indicates
1576 a decimal floating point number regardless of the radix. */
1577 else if (!got_dot && *p == '.')
1579 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1580 && (*p == '-' || *p == '+'))
1581 /* This is the sign of the exponent, not the end of the
1584 /* We will take any letters or digits. parse_number will
1585 complain if past the radix, or if L or U are not final. */
1586 else if ((*p < '0' || *p > '9')
1587 && ((*p < 'a' || *p > 'z')
1588 && (*p < 'A' || *p > 'Z')))
1591 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1592 if (toktype == ERROR)
1594 char *err_copy = (char *) alloca (p - tokstart + 1);
1596 memcpy (err_copy, tokstart, p - tokstart);
1597 err_copy[p - tokstart] = 0;
1598 error ("Invalid number \"%s\".", err_copy);
1630 /* Build the gdb internal form of the input string in tempbuf,
1631 translating any standard C escape forms seen. Note that the
1632 buffer is null byte terminated *only* for the convenience of
1633 debugging gdb itself and printing the buffer contents when
1634 the buffer contains no embedded nulls. Gdb does not depend
1635 upon the buffer being null byte terminated, it uses the length
1636 string instead. This allows gdb to handle C strings (as well
1637 as strings in other languages) with embedded null bytes */
1639 tokptr = ++tokstart;
1643 char *char_start_pos = tokptr;
1645 /* Grow the static temp buffer if necessary, including allocating
1646 the first one on demand. */
1647 if (tempbufindex + 1 >= tempbufsize)
1649 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1655 /* Do nothing, loop will terminate. */
1659 c = parse_escape (&tokptr);
1664 tempbuf[tempbufindex++] = c;
1668 if (! host_char_to_target (c, &c))
1670 int len = tokptr - char_start_pos;
1671 char *copy = alloca (len + 1);
1672 memcpy (copy, char_start_pos, len);
1675 error ("There is no character corresponding to `%s' "
1676 "in the target character set `%s'.",
1677 copy, target_charset ());
1679 tempbuf[tempbufindex++] = c;
1682 } while ((*tokptr != '"') && (*tokptr != '\0'));
1683 if (*tokptr++ != '"')
1685 error ("Unterminated string in expression.");
1687 tempbuf[tempbufindex] = '\0'; /* See note above */
1688 yylval.sval.ptr = tempbuf;
1689 yylval.sval.length = tempbufindex;
1694 if (!(c == '_' || c == '$'
1695 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1696 /* We must have come across a bad character (e.g. ';'). */
1697 error ("Invalid character '%c' in expression.", c);
1699 /* It's a name. See how long it is. */
1701 for (c = tokstart[namelen];
1702 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1703 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1705 /* Template parameter lists are part of the name.
1706 FIXME: This mishandles `print $a<4&&$a>3'. */
1710 /* Scan ahead to get rest of the template specification. Note
1711 that we look ahead only when the '<' adjoins non-whitespace
1712 characters; for comparison expressions, e.g. "a < b > c",
1713 there must be spaces before the '<', etc. */
1715 char * p = find_template_name_end (tokstart + namelen);
1717 namelen = p - tokstart;
1720 c = tokstart[++namelen];
1723 /* The token "if" terminates the expression and is NOT removed from
1724 the input stream. It doesn't count if it appears in the
1725 expansion of a macro. */
1727 && tokstart[0] == 'i'
1728 && tokstart[1] == 'f'
1729 && ! scanning_macro_expansion ())
1738 /* Catch specific keywords. Should be done with a data structure. */
1742 if (strncmp (tokstart, "unsigned", 8) == 0)
1744 if (current_language->la_language == language_cplus
1745 && strncmp (tokstart, "template", 8) == 0)
1747 if (strncmp (tokstart, "volatile", 8) == 0)
1748 return VOLATILE_KEYWORD;
1751 if (strncmp (tokstart, "struct", 6) == 0)
1753 if (strncmp (tokstart, "signed", 6) == 0)
1754 return SIGNED_KEYWORD;
1755 if (strncmp (tokstart, "sizeof", 6) == 0)
1757 if (strncmp (tokstart, "double", 6) == 0)
1758 return DOUBLE_KEYWORD;
1761 if (current_language->la_language == language_cplus)
1763 if (strncmp (tokstart, "false", 5) == 0)
1764 return FALSEKEYWORD;
1765 if (strncmp (tokstart, "class", 5) == 0)
1768 if (strncmp (tokstart, "union", 5) == 0)
1770 if (strncmp (tokstart, "short", 5) == 0)
1772 if (strncmp (tokstart, "const", 5) == 0)
1773 return CONST_KEYWORD;
1776 if (strncmp (tokstart, "enum", 4) == 0)
1778 if (strncmp (tokstart, "long", 4) == 0)
1780 if (current_language->la_language == language_cplus)
1782 if (strncmp (tokstart, "true", 4) == 0)
1787 if (strncmp (tokstart, "int", 3) == 0)
1794 yylval.sval.ptr = tokstart;
1795 yylval.sval.length = namelen;
1797 if (*tokstart == '$')
1799 write_dollar_variable (yylval.sval);
1803 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1804 functions or symtabs. If this is not so, then ...
1805 Use token-type TYPENAME for symbols that happen to be defined
1806 currently as names of types; NAME for other symbols.
1807 The caller is not constrained to care about the distinction. */
1809 char *tmp = copy_name (yylval.sval);
1811 int is_a_field_of_this = 0;
1814 sym = lookup_symbol (tmp, expression_context_block,
1816 current_language->la_language == language_cplus
1817 ? &is_a_field_of_this : (int *) NULL);
1818 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1819 no psymtabs (coff, xcoff, or some future change to blow away the
1820 psymtabs once once symbols are read). */
1821 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1823 yylval.ssym.sym = sym;
1824 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1828 { /* See if it's a file name. */
1829 struct symtab *symtab;
1831 symtab = lookup_symtab (tmp);
1835 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1840 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1842 /* NOTE: carlton/2003-09-25: There used to be code here to
1843 handle nested types. It didn't work very well. See the
1844 comment before qualified_type for more info. */
1845 yylval.tsym.type = SYMBOL_TYPE (sym);
1849 = language_lookup_primitive_type_by_name (current_language,
1850 current_gdbarch, tmp);
1851 if (yylval.tsym.type != NULL)
1854 /* Input names that aren't symbols but ARE valid hex numbers,
1855 when the input radix permits them, can be names or numbers
1856 depending on the parse. Note we support radixes > 16 here. */
1858 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1859 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1861 YYSTYPE newlval; /* Its value is ignored. */
1862 hextype = parse_number (tokstart, namelen, 0, &newlval);
1865 yylval.ssym.sym = sym;
1866 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1871 /* Any other kind of symbol */
1872 yylval.ssym.sym = sym;
1873 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1874 if (in_parse_field && *lexptr == '\0')
1875 saw_name_at_eof = 1;
1883 last_was_structop = 0;
1884 saw_name_at_eof = 0;
1893 lexptr = prev_lexptr;
1895 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);