1 /* YACC parser for C expressions, for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 /* Parse a C expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result.
31 Note that malloc's and realloc's in this file are transformed to
32 xmalloc and xrealloc respectively by the same sed command in the
33 makefile that remaps any other malloc/realloc inserted by the parser
34 generator. Doing this with #defines and trying to control the interaction
35 with include files (<malloc.h> and <stdlib.h> for example) just became
36 too messy, particularly when such includes can be inserted at random
37 times by the parser generator. */
42 #include "gdb_string.h"
44 #include "expression.h"
46 #include "parser-defs.h"
49 #include "bfd.h" /* Required by objfiles.h. */
50 #include "symfile.h" /* Required by objfiles.h. */
51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52 #include "completer.h" /* For skip_quoted(). */
54 /* Flag indicating we're dealing with HP-compiled objects */
55 extern int hp_som_som_object_present;
57 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
58 as well as gratuitiously global symbol names, so we can have multiple
59 yacc generated parsers in gdb. Note that these are only the variables
60 produced by yacc. If other parser generators (bison, byacc, etc) produce
61 additional global names that conflict at link time, then those parser
62 generators need to be fixed instead of adding those names to this list. */
64 #define yymaxdepth c_maxdepth
65 #define yyparse c_parse
67 #define yyerror c_error
70 #define yydebug c_debug
79 #define yyerrflag c_errflag
80 #define yynerrs c_nerrs
85 #define yystate c_state
91 #define yyreds c_reds /* With YYDEBUG defined */
92 #define yytoks c_toks /* With YYDEBUG defined */
93 #define yyname c_name /* With YYDEBUG defined */
94 #define yyrule c_rule /* With YYDEBUG defined */
97 #define yydefred c_yydefred
98 #define yydgoto c_yydgoto
99 #define yysindex c_yysindex
100 #define yyrindex c_yyrindex
101 #define yygindex c_yygindex
102 #define yytable c_yytable
103 #define yycheck c_yycheck
106 #define YYDEBUG 1 /* Default to yydebug support */
109 #define YYFPRINTF parser_fprintf
113 static int yylex (void);
115 void yyerror (char *);
119 /* Although the yacc "value" of an expression is not used,
120 since the result is stored in the structure being created,
121 other node types do have values. */
138 struct symtoken ssym;
141 enum exp_opcode opcode;
142 struct internalvar *ivar;
149 /* YYSTYPE gets defined by %union */
150 static int parse_number (char *, int, int, YYSTYPE *);
153 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
155 %type <tval> type typebase
156 %type <tvec> nonempty_typelist
157 /* %type <bval> block */
159 /* Fancy type parsing. */
160 %type <voidval> func_mod direct_abs_decl abs_decl
162 %type <lval> array_mod
164 %token <typed_val_int> INT
165 %token <typed_val_float> FLOAT
167 /* Both NAME and TYPENAME tokens represent symbols in the input,
168 and both convey their data as strings.
169 But a TYPENAME is a string that happens to be defined as a typedef
170 or builtin type name (such as int or char)
171 and a NAME is any other symbol.
172 Contexts where this distinction is not important can use the
173 nonterminal "name", which matches either NAME or TYPENAME. */
176 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
177 %token <tsym> TYPENAME
179 %type <ssym> name_not_typename
180 %type <tsym> typename
182 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
183 but which would parse as a valid number in the current input radix.
184 E.g. "c" when input_radix==16. Depending on the parse, it will be
185 turned into a name or into a number. */
187 %token <ssym> NAME_OR_INT
189 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
193 /* Special type cases, put in to allow the parser to distinguish different
195 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
197 %token <voidval> VARIABLE
199 %token <opcode> ASSIGN_MODIFY
209 %right '=' ASSIGN_MODIFY
217 %left '<' '>' LEQ GEQ
222 %right UNARY INCREMENT DECREMENT
223 %right ARROW '.' '[' '('
224 %token <ssym> BLOCKNAME
225 %token <bval> FILENAME
237 { write_exp_elt_opcode(OP_TYPE);
238 write_exp_elt_type($1);
239 write_exp_elt_opcode(OP_TYPE);}
242 /* Expressions, including the comma operator. */
245 { write_exp_elt_opcode (BINOP_COMMA); }
248 /* Expressions, not including the comma operator. */
249 exp : '*' exp %prec UNARY
250 { write_exp_elt_opcode (UNOP_IND); }
252 exp : '&' exp %prec UNARY
253 { write_exp_elt_opcode (UNOP_ADDR); }
255 exp : '-' exp %prec UNARY
256 { write_exp_elt_opcode (UNOP_NEG); }
259 exp : '!' exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
263 exp : '~' exp %prec UNARY
264 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
267 exp : INCREMENT exp %prec UNARY
268 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
271 exp : DECREMENT exp %prec UNARY
272 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
275 exp : exp INCREMENT %prec UNARY
276 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
279 exp : exp DECREMENT %prec UNARY
280 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
283 exp : SIZEOF exp %prec UNARY
284 { write_exp_elt_opcode (UNOP_SIZEOF); }
288 { write_exp_elt_opcode (STRUCTOP_PTR);
289 write_exp_string ($3);
290 write_exp_elt_opcode (STRUCTOP_PTR); }
293 exp : exp ARROW qualified_name
294 { /* exp->type::name becomes exp->*(&type::name) */
295 /* Note: this doesn't work if name is a
296 static member! FIXME */
297 write_exp_elt_opcode (UNOP_ADDR);
298 write_exp_elt_opcode (STRUCTOP_MPTR); }
301 exp : exp ARROW '*' exp
302 { write_exp_elt_opcode (STRUCTOP_MPTR); }
306 { write_exp_elt_opcode (STRUCTOP_STRUCT);
307 write_exp_string ($3);
308 write_exp_elt_opcode (STRUCTOP_STRUCT); }
311 exp : exp '.' qualified_name
312 { /* exp.type::name becomes exp.*(&type::name) */
313 /* Note: this doesn't work if name is a
314 static member! FIXME */
315 write_exp_elt_opcode (UNOP_ADDR);
316 write_exp_elt_opcode (STRUCTOP_MEMBER); }
319 exp : exp '.' '*' exp
320 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
323 exp : exp '[' exp1 ']'
324 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
328 /* This is to save the value of arglist_len
329 being accumulated by an outer function call. */
330 { start_arglist (); }
331 arglist ')' %prec ARROW
332 { write_exp_elt_opcode (OP_FUNCALL);
333 write_exp_elt_longcst ((LONGEST) end_arglist ());
334 write_exp_elt_opcode (OP_FUNCALL); }
338 { start_arglist (); }
348 arglist : arglist ',' exp %prec ABOVE_COMMA
353 { $$ = end_arglist () - 1; }
355 exp : lcurly arglist rcurly %prec ARROW
356 { write_exp_elt_opcode (OP_ARRAY);
357 write_exp_elt_longcst ((LONGEST) 0);
358 write_exp_elt_longcst ((LONGEST) $3);
359 write_exp_elt_opcode (OP_ARRAY); }
362 exp : lcurly type rcurly exp %prec UNARY
363 { write_exp_elt_opcode (UNOP_MEMVAL);
364 write_exp_elt_type ($2);
365 write_exp_elt_opcode (UNOP_MEMVAL); }
368 exp : '(' type ')' exp %prec UNARY
369 { write_exp_elt_opcode (UNOP_CAST);
370 write_exp_elt_type ($2);
371 write_exp_elt_opcode (UNOP_CAST); }
378 /* Binary operators in order of decreasing precedence. */
381 { write_exp_elt_opcode (BINOP_REPEAT); }
385 { write_exp_elt_opcode (BINOP_MUL); }
389 { write_exp_elt_opcode (BINOP_DIV); }
393 { write_exp_elt_opcode (BINOP_REM); }
397 { write_exp_elt_opcode (BINOP_ADD); }
401 { write_exp_elt_opcode (BINOP_SUB); }
405 { write_exp_elt_opcode (BINOP_LSH); }
409 { write_exp_elt_opcode (BINOP_RSH); }
413 { write_exp_elt_opcode (BINOP_EQUAL); }
416 exp : exp NOTEQUAL exp
417 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
421 { write_exp_elt_opcode (BINOP_LEQ); }
425 { write_exp_elt_opcode (BINOP_GEQ); }
429 { write_exp_elt_opcode (BINOP_LESS); }
433 { write_exp_elt_opcode (BINOP_GTR); }
437 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
441 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
445 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
449 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
453 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
456 exp : exp '?' exp ':' exp %prec '?'
457 { write_exp_elt_opcode (TERNOP_COND); }
461 { write_exp_elt_opcode (BINOP_ASSIGN); }
464 exp : exp ASSIGN_MODIFY exp
465 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
466 write_exp_elt_opcode ($2);
467 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
471 { write_exp_elt_opcode (OP_LONG);
472 write_exp_elt_type ($1.type);
473 write_exp_elt_longcst ((LONGEST)($1.val));
474 write_exp_elt_opcode (OP_LONG); }
479 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
480 write_exp_elt_opcode (OP_LONG);
481 write_exp_elt_type (val.typed_val_int.type);
482 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
483 write_exp_elt_opcode (OP_LONG);
489 { write_exp_elt_opcode (OP_DOUBLE);
490 write_exp_elt_type ($1.type);
491 write_exp_elt_dblcst ($1.dval);
492 write_exp_elt_opcode (OP_DOUBLE); }
499 /* Already written by write_dollar_variable. */
502 exp : SIZEOF '(' type ')' %prec UNARY
503 { write_exp_elt_opcode (OP_LONG);
504 write_exp_elt_type (builtin_type_int);
506 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
507 write_exp_elt_opcode (OP_LONG); }
511 { /* C strings are converted into array constants with
512 an explicit null byte added at the end. Thus
513 the array upper bound is the string length.
514 There is no such thing in C as a completely empty
516 char *sp = $1.ptr; int count = $1.length;
519 write_exp_elt_opcode (OP_LONG);
520 write_exp_elt_type (builtin_type_char);
521 write_exp_elt_longcst ((LONGEST)(*sp++));
522 write_exp_elt_opcode (OP_LONG);
524 write_exp_elt_opcode (OP_LONG);
525 write_exp_elt_type (builtin_type_char);
526 write_exp_elt_longcst ((LONGEST)'\0');
527 write_exp_elt_opcode (OP_LONG);
528 write_exp_elt_opcode (OP_ARRAY);
529 write_exp_elt_longcst ((LONGEST) 0);
530 write_exp_elt_longcst ((LONGEST) ($1.length));
531 write_exp_elt_opcode (OP_ARRAY); }
536 { write_exp_elt_opcode (OP_THIS);
537 write_exp_elt_opcode (OP_THIS); }
541 { write_exp_elt_opcode (OP_LONG);
542 write_exp_elt_type (builtin_type_bool);
543 write_exp_elt_longcst ((LONGEST) 1);
544 write_exp_elt_opcode (OP_LONG); }
548 { write_exp_elt_opcode (OP_LONG);
549 write_exp_elt_type (builtin_type_bool);
550 write_exp_elt_longcst ((LONGEST) 0);
551 write_exp_elt_opcode (OP_LONG); }
559 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
561 error ("No file or function \"%s\".",
562 copy_name ($1.stoken));
570 block : block COLONCOLON name
572 = lookup_symbol (copy_name ($3), $1,
573 VAR_NAMESPACE, (int *) NULL,
574 (struct symtab **) NULL);
575 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
576 error ("No function \"%s\" in specified context.",
578 $$ = SYMBOL_BLOCK_VALUE (tem); }
581 variable: block COLONCOLON name
582 { struct symbol *sym;
583 sym = lookup_symbol (copy_name ($3), $1,
584 VAR_NAMESPACE, (int *) NULL,
585 (struct symtab **) NULL);
587 error ("No symbol \"%s\" in specified context.",
590 write_exp_elt_opcode (OP_VAR_VALUE);
591 /* block_found is set by lookup_symbol. */
592 write_exp_elt_block (block_found);
593 write_exp_elt_sym (sym);
594 write_exp_elt_opcode (OP_VAR_VALUE); }
597 qualified_name: typebase COLONCOLON name
599 struct type *type = $1;
600 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
601 && TYPE_CODE (type) != TYPE_CODE_UNION)
602 error ("`%s' is not defined as an aggregate type.",
605 write_exp_elt_opcode (OP_SCOPE);
606 write_exp_elt_type (type);
607 write_exp_string ($3);
608 write_exp_elt_opcode (OP_SCOPE);
610 | typebase COLONCOLON '~' name
612 struct type *type = $1;
613 struct stoken tmp_token;
614 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
615 && TYPE_CODE (type) != TYPE_CODE_UNION)
616 error ("`%s' is not defined as an aggregate type.",
619 tmp_token.ptr = (char*) alloca ($4.length + 2);
620 tmp_token.length = $4.length + 1;
621 tmp_token.ptr[0] = '~';
622 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
623 tmp_token.ptr[tmp_token.length] = 0;
625 /* Check for valid destructor name. */
626 destructor_name_p (tmp_token.ptr, type);
627 write_exp_elt_opcode (OP_SCOPE);
628 write_exp_elt_type (type);
629 write_exp_string (tmp_token);
630 write_exp_elt_opcode (OP_SCOPE);
634 variable: qualified_name
637 char *name = copy_name ($2);
639 struct minimal_symbol *msymbol;
642 lookup_symbol (name, (const struct block *) NULL,
643 VAR_NAMESPACE, (int *) NULL,
644 (struct symtab **) NULL);
647 write_exp_elt_opcode (OP_VAR_VALUE);
648 write_exp_elt_block (NULL);
649 write_exp_elt_sym (sym);
650 write_exp_elt_opcode (OP_VAR_VALUE);
654 msymbol = lookup_minimal_symbol (name, NULL, NULL);
657 write_exp_msymbol (msymbol,
658 lookup_function_type (builtin_type_int),
662 if (!have_full_symbols () && !have_partial_symbols ())
663 error ("No symbol table is loaded. Use the \"file\" command.");
665 error ("No symbol \"%s\" in current context.", name);
669 variable: name_not_typename
670 { struct symbol *sym = $1.sym;
674 if (symbol_read_needs_frame (sym))
676 if (innermost_block == 0 ||
677 contained_in (block_found,
679 innermost_block = block_found;
682 write_exp_elt_opcode (OP_VAR_VALUE);
683 /* We want to use the selected frame, not
684 another more inner frame which happens to
685 be in the same block. */
686 write_exp_elt_block (NULL);
687 write_exp_elt_sym (sym);
688 write_exp_elt_opcode (OP_VAR_VALUE);
690 else if ($1.is_a_field_of_this)
692 /* C++: it hangs off of `this'. Must
693 not inadvertently convert from a method call
695 if (innermost_block == 0 ||
696 contained_in (block_found, innermost_block))
697 innermost_block = block_found;
698 write_exp_elt_opcode (OP_THIS);
699 write_exp_elt_opcode (OP_THIS);
700 write_exp_elt_opcode (STRUCTOP_PTR);
701 write_exp_string ($1.stoken);
702 write_exp_elt_opcode (STRUCTOP_PTR);
706 struct minimal_symbol *msymbol;
707 register char *arg = copy_name ($1.stoken);
710 lookup_minimal_symbol (arg, NULL, NULL);
713 write_exp_msymbol (msymbol,
714 lookup_function_type (builtin_type_int),
717 else if (!have_full_symbols () && !have_partial_symbols ())
718 error ("No symbol table is loaded. Use the \"file\" command.");
720 error ("No symbol \"%s\" in current context.",
721 copy_name ($1.stoken));
726 space_identifier : '@' NAME
727 { push_type_address_space (copy_name ($2.stoken));
728 push_type (tp_space_identifier);
732 const_or_volatile: const_or_volatile_noopt
736 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
739 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
740 | const_or_volatile_noopt
743 const_or_volatile_or_space_identifier:
744 const_or_volatile_or_space_identifier_noopt
749 { push_type (tp_pointer); $$ = 0; }
751 { push_type (tp_pointer); $$ = $2; }
753 { push_type (tp_reference); $$ = 0; }
755 { push_type (tp_reference); $$ = $2; }
759 direct_abs_decl: '(' abs_decl ')'
761 | direct_abs_decl array_mod
764 push_type (tp_array);
769 push_type (tp_array);
773 | direct_abs_decl func_mod
774 { push_type (tp_function); }
776 { push_type (tp_function); }
787 | '(' nonempty_typelist ')'
788 { free ((PTR)$2); $$ = 0; }
791 /* We used to try to recognize more pointer to member types here, but
792 that didn't work (shift/reduce conflicts meant that these rules never
793 got executed). The problem is that
794 int (foo::bar::baz::bizzle)
795 is a function type but
796 int (foo::bar::baz::bizzle::*)
797 is a pointer to member type. Stroustrup loses again! */
800 | typebase COLONCOLON '*'
801 { $$ = lookup_member_type (builtin_type_int, $1); }
804 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
808 { $$ = builtin_type_int; }
810 { $$ = builtin_type_long; }
812 { $$ = builtin_type_short; }
814 { $$ = builtin_type_long; }
815 | LONG SIGNED_KEYWORD INT_KEYWORD
816 { $$ = builtin_type_long; }
817 | LONG SIGNED_KEYWORD
818 { $$ = builtin_type_long; }
819 | SIGNED_KEYWORD LONG INT_KEYWORD
820 { $$ = builtin_type_long; }
821 | UNSIGNED LONG INT_KEYWORD
822 { $$ = builtin_type_unsigned_long; }
823 | LONG UNSIGNED INT_KEYWORD
824 { $$ = builtin_type_unsigned_long; }
826 { $$ = builtin_type_unsigned_long; }
828 { $$ = builtin_type_long_long; }
829 | LONG LONG INT_KEYWORD
830 { $$ = builtin_type_long_long; }
831 | LONG LONG SIGNED_KEYWORD INT_KEYWORD
832 { $$ = builtin_type_long_long; }
833 | LONG LONG SIGNED_KEYWORD
834 { $$ = builtin_type_long_long; }
835 | SIGNED_KEYWORD LONG LONG
836 { $$ = builtin_type_long_long; }
838 { $$ = builtin_type_unsigned_long_long; }
839 | UNSIGNED LONG LONG INT_KEYWORD
840 { $$ = builtin_type_unsigned_long_long; }
842 { $$ = builtin_type_unsigned_long_long; }
843 | LONG LONG UNSIGNED INT_KEYWORD
844 { $$ = builtin_type_unsigned_long_long; }
845 | SIGNED_KEYWORD LONG LONG
846 { $$ = lookup_signed_typename ("long long"); }
847 | SIGNED_KEYWORD LONG LONG INT_KEYWORD
848 { $$ = lookup_signed_typename ("long long"); }
850 { $$ = builtin_type_short; }
851 | SHORT SIGNED_KEYWORD INT_KEYWORD
852 { $$ = builtin_type_short; }
853 | SHORT SIGNED_KEYWORD
854 { $$ = builtin_type_short; }
855 | UNSIGNED SHORT INT_KEYWORD
856 { $$ = builtin_type_unsigned_short; }
858 { $$ = builtin_type_unsigned_short; }
859 | SHORT UNSIGNED INT_KEYWORD
860 { $$ = builtin_type_unsigned_short; }
862 { $$ = builtin_type_double; }
863 | LONG DOUBLE_KEYWORD
864 { $$ = builtin_type_long_double; }
866 { $$ = lookup_struct (copy_name ($2),
867 expression_context_block); }
869 { $$ = lookup_struct (copy_name ($2),
870 expression_context_block); }
872 { $$ = lookup_union (copy_name ($2),
873 expression_context_block); }
875 { $$ = lookup_enum (copy_name ($2),
876 expression_context_block); }
878 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
880 { $$ = builtin_type_unsigned_int; }
881 | SIGNED_KEYWORD typename
882 { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
884 { $$ = builtin_type_int; }
885 /* It appears that this rule for templates is never
886 reduced; template recognition happens by lookahead
887 in the token processing code in yylex. */
888 | TEMPLATE name '<' type '>'
889 { $$ = lookup_template_type(copy_name($2), $4,
890 expression_context_block);
892 | const_or_volatile_or_space_identifier_noopt typebase
893 { $$ = follow_types ($2); }
894 | typebase const_or_volatile_or_space_identifier_noopt
895 { $$ = follow_types ($1); }
901 $$.stoken.ptr = "int";
902 $$.stoken.length = 3;
903 $$.type = builtin_type_int;
907 $$.stoken.ptr = "long";
908 $$.stoken.length = 4;
909 $$.type = builtin_type_long;
913 $$.stoken.ptr = "short";
914 $$.stoken.length = 5;
915 $$.type = builtin_type_short;
921 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
922 $<ivec>$[0] = 1; /* Number of types in vector */
925 | nonempty_typelist ',' type
926 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
927 $$ = (struct type **) realloc ((char *) $1, len);
928 $$[$<ivec>$[0]] = $3;
933 | ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
934 { $$ = follow_types ($1); }
937 const_and_volatile: CONST_KEYWORD VOLATILE_KEYWORD
938 | VOLATILE_KEYWORD CONST_KEYWORD
941 const_or_volatile_noopt: const_and_volatile
942 { push_type (tp_const);
943 push_type (tp_volatile);
946 { push_type (tp_const); }
948 { push_type (tp_volatile); }
951 name : NAME { $$ = $1.stoken; }
952 | BLOCKNAME { $$ = $1.stoken; }
953 | TYPENAME { $$ = $1.stoken; }
954 | NAME_OR_INT { $$ = $1.stoken; }
957 name_not_typename : NAME
959 /* These would be useful if name_not_typename was useful, but it is just
960 a fake for "variable", so these cause reduce/reduce conflicts because
961 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
962 =exp) or just an exp. If name_not_typename was ever used in an lvalue
963 context where only a name could occur, this might be useful.
970 /* Take care of parsing a number (anything that starts with a digit).
971 Set yylval and return the token type; update lexptr.
972 LEN is the number of characters in it. */
974 /*** Needs some error checking for the float case ***/
977 parse_number (p, len, parsed_float, putithere)
983 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
984 here, and we do kind of silly things like cast to unsigned. */
985 register LONGEST n = 0;
986 register LONGEST prevn = 0;
991 register int base = input_radix;
994 /* Number of "L" suffixes encountered. */
997 /* We have found a "L" or "U" suffix. */
998 int found_suffix = 0;
1001 struct type *signed_type;
1002 struct type *unsigned_type;
1006 /* It's a float since it contains a point or an exponent. */
1008 int num = 0; /* number of tokens scanned by scanf */
1009 char saved_char = p[len];
1011 p[len] = 0; /* null-terminate the token */
1012 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
1013 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval,&c);
1014 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
1015 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval,&c);
1018 #ifdef SCANF_HAS_LONG_DOUBLE
1019 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval,&c);
1021 /* Scan it into a double, then assign it to the long double.
1022 This at least wins with values representable in the range
1025 num = sscanf (p, "%lg%c", &temp,&c);
1026 putithere->typed_val_float.dval = temp;
1029 p[len] = saved_char; /* restore the input stream */
1030 if (num != 1) /* check scanf found ONLY a float ... */
1032 /* See if it has `f' or `l' suffix (float or long double). */
1034 c = tolower (p[len - 1]);
1037 putithere->typed_val_float.type = builtin_type_float;
1039 putithere->typed_val_float.type = builtin_type_long_double;
1040 else if (isdigit (c) || c == '.')
1041 putithere->typed_val_float.type = builtin_type_double;
1048 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1082 if (c >= 'A' && c <= 'Z')
1084 if (c != 'l' && c != 'u')
1086 if (c >= '0' && c <= '9')
1094 if (base > 10 && c >= 'a' && c <= 'f')
1098 n += i = c - 'a' + 10;
1111 return ERROR; /* Char not a digit */
1114 return ERROR; /* Invalid digit in this base */
1116 /* Portably test for overflow (only works for nonzero values, so make
1117 a second check for zero). FIXME: Can't we just make n and prevn
1118 unsigned and avoid this? */
1119 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1120 unsigned_p = 1; /* Try something unsigned */
1122 /* Portably test for unsigned overflow.
1123 FIXME: This check is wrong; for example it doesn't find overflow
1124 on 0x123456789 when LONGEST is 32 bits. */
1125 if (c != 'l' && c != 'u' && n != 0)
1127 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1128 error ("Numeric constant too large.");
1133 /* An integer constant is an int, a long, or a long long. An L
1134 suffix forces it to be long; an LL suffix forces it to be long
1135 long. If not forced to a larger size, it gets the first type of
1136 the above that it fits in. To figure out whether it fits, we
1137 shift it right and see whether anything remains. Note that we
1138 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1139 operation, because many compilers will warn about such a shift
1140 (which always produces a zero result). Sometimes TARGET_INT_BIT
1141 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
1142 the case where it is we just always shift the value more than
1143 once, with fewer bits each time. */
1145 un = (ULONGEST)n >> 2;
1147 && (un >> (TARGET_INT_BIT - 2)) == 0)
1149 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
1151 /* A large decimal (not hex or octal) constant (between INT_MAX
1152 and UINT_MAX) is a long or unsigned long, according to ANSI,
1153 never an unsigned int, but this code treats it as unsigned
1154 int. This probably should be fixed. GCC gives a warning on
1157 unsigned_type = builtin_type_unsigned_int;
1158 signed_type = builtin_type_int;
1160 else if (long_p <= 1
1161 && (un >> (TARGET_LONG_BIT - 2)) == 0)
1163 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
1164 unsigned_type = builtin_type_unsigned_long;
1165 signed_type = builtin_type_long;
1170 if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
1171 /* A long long does not fit in a LONGEST. */
1172 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1174 shift = (TARGET_LONG_LONG_BIT - 1);
1175 high_bit = (ULONGEST) 1 << shift;
1176 unsigned_type = builtin_type_unsigned_long_long;
1177 signed_type = builtin_type_long_long;
1180 putithere->typed_val_int.val = n;
1182 /* If the high bit of the worked out type is set then this number
1183 has to be unsigned. */
1185 if (unsigned_p || (n & high_bit))
1187 putithere->typed_val_int.type = unsigned_type;
1191 putithere->typed_val_int.type = signed_type;
1201 enum exp_opcode opcode;
1204 static const struct token tokentab3[] =
1206 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1207 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1210 static const struct token tokentab2[] =
1212 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1213 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1214 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1215 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1216 {"%=", ASSIGN_MODIFY, BINOP_REM},
1217 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1218 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1219 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1220 {"++", INCREMENT, BINOP_END},
1221 {"--", DECREMENT, BINOP_END},
1222 {"->", ARROW, BINOP_END},
1223 {"&&", ANDAND, BINOP_END},
1224 {"||", OROR, BINOP_END},
1225 {"::", COLONCOLON, BINOP_END},
1226 {"<<", LSH, BINOP_END},
1227 {">>", RSH, BINOP_END},
1228 {"==", EQUAL, BINOP_END},
1229 {"!=", NOTEQUAL, BINOP_END},
1230 {"<=", LEQ, BINOP_END},
1231 {">=", GEQ, BINOP_END}
1234 /* Read one token, getting characters through lexptr. */
1245 static char *tempbuf;
1246 static int tempbufsize;
1247 struct symbol * sym_class = NULL;
1248 char * token_string = NULL;
1249 int class_prefix = 0;
1254 /* Check if this is a macro invocation that we need to expand. */
1255 if (! scanning_macro_expansion ())
1257 char *expanded = macro_expand_next (&lexptr,
1258 expression_macro_lookup_func,
1259 expression_macro_lookup_baton);
1262 scan_macro_expansion (expanded);
1265 prev_lexptr = lexptr;
1269 /* See if it is a special token of length 3. */
1270 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1271 if (STREQN (tokstart, tokentab3[i].operator, 3))
1274 yylval.opcode = tokentab3[i].opcode;
1275 return tokentab3[i].token;
1278 /* See if it is a special token of length 2. */
1279 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1280 if (STREQN (tokstart, tokentab2[i].operator, 2))
1283 yylval.opcode = tokentab2[i].opcode;
1284 return tokentab2[i].token;
1287 switch (c = *tokstart)
1290 /* If we were just scanning the result of a macro expansion,
1291 then we need to resume scanning the original text.
1292 Otherwise, we were already scanning the original text, and
1293 we're really done. */
1294 if (scanning_macro_expansion ())
1296 finished_macro_expansion ();
1309 /* We either have a character constant ('0' or '\177' for example)
1310 or we have a quoted symbol reference ('foo(int,int)' in C++
1315 c = parse_escape (&lexptr);
1317 error ("Empty character constant.");
1319 yylval.typed_val_int.val = c;
1320 yylval.typed_val_int.type = builtin_type_char;
1325 namelen = skip_quoted (tokstart) - tokstart;
1328 lexptr = tokstart + namelen;
1330 if (lexptr[-1] != '\'')
1331 error ("Unmatched single quote.");
1336 error ("Invalid character constant.");
1346 if (paren_depth == 0)
1353 if (comma_terminates
1355 && ! scanning_macro_expansion ())
1361 /* Might be a floating point number. */
1362 if (lexptr[1] < '0' || lexptr[1] > '9')
1363 goto symbol; /* Nope, must be a symbol. */
1364 /* FALL THRU into number case. */
1377 /* It's a number. */
1378 int got_dot = 0, got_e = 0, toktype;
1379 register char *p = tokstart;
1380 int hex = input_radix > 10;
1382 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1387 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1395 /* This test includes !hex because 'e' is a valid hex digit
1396 and thus does not indicate a floating point number when
1397 the radix is hex. */
1398 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1399 got_dot = got_e = 1;
1400 /* This test does not include !hex, because a '.' always indicates
1401 a decimal floating point number regardless of the radix. */
1402 else if (!got_dot && *p == '.')
1404 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1405 && (*p == '-' || *p == '+'))
1406 /* This is the sign of the exponent, not the end of the
1409 /* We will take any letters or digits. parse_number will
1410 complain if past the radix, or if L or U are not final. */
1411 else if ((*p < '0' || *p > '9')
1412 && ((*p < 'a' || *p > 'z')
1413 && (*p < 'A' || *p > 'Z')))
1416 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1417 if (toktype == ERROR)
1419 char *err_copy = (char *) alloca (p - tokstart + 1);
1421 memcpy (err_copy, tokstart, p - tokstart);
1422 err_copy[p - tokstart] = 0;
1423 error ("Invalid number \"%s\".", err_copy);
1455 /* Build the gdb internal form of the input string in tempbuf,
1456 translating any standard C escape forms seen. Note that the
1457 buffer is null byte terminated *only* for the convenience of
1458 debugging gdb itself and printing the buffer contents when
1459 the buffer contains no embedded nulls. Gdb does not depend
1460 upon the buffer being null byte terminated, it uses the length
1461 string instead. This allows gdb to handle C strings (as well
1462 as strings in other languages) with embedded null bytes */
1464 tokptr = ++tokstart;
1468 /* Grow the static temp buffer if necessary, including allocating
1469 the first one on demand. */
1470 if (tempbufindex + 1 >= tempbufsize)
1472 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1478 /* Do nothing, loop will terminate. */
1482 c = parse_escape (&tokptr);
1487 tempbuf[tempbufindex++] = c;
1490 tempbuf[tempbufindex++] = *tokptr++;
1493 } while ((*tokptr != '"') && (*tokptr != '\0'));
1494 if (*tokptr++ != '"')
1496 error ("Unterminated string in expression.");
1498 tempbuf[tempbufindex] = '\0'; /* See note above */
1499 yylval.sval.ptr = tempbuf;
1500 yylval.sval.length = tempbufindex;
1505 if (!(c == '_' || c == '$'
1506 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1507 /* We must have come across a bad character (e.g. ';'). */
1508 error ("Invalid character '%c' in expression.", c);
1510 /* It's a name. See how long it is. */
1512 for (c = tokstart[namelen];
1513 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1514 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1516 /* Template parameter lists are part of the name.
1517 FIXME: This mishandles `print $a<4&&$a>3'. */
1521 /* Scan ahead to get rest of the template specification. Note
1522 that we look ahead only when the '<' adjoins non-whitespace
1523 characters; for comparison expressions, e.g. "a < b > c",
1524 there must be spaces before the '<', etc. */
1526 char * p = find_template_name_end (tokstart + namelen);
1528 namelen = p - tokstart;
1531 c = tokstart[++namelen];
1534 /* The token "if" terminates the expression and is NOT removed from
1535 the input stream. It doesn't count if it appears in the
1536 expansion of a macro. */
1538 && tokstart[0] == 'i'
1539 && tokstart[1] == 'f'
1540 && ! scanning_macro_expansion ())
1549 /* Catch specific keywords. Should be done with a data structure. */
1553 if (STREQN (tokstart, "unsigned", 8))
1555 if (current_language->la_language == language_cplus
1556 && STREQN (tokstart, "template", 8))
1558 if (STREQN (tokstart, "volatile", 8))
1559 return VOLATILE_KEYWORD;
1562 if (STREQN (tokstart, "struct", 6))
1564 if (STREQN (tokstart, "signed", 6))
1565 return SIGNED_KEYWORD;
1566 if (STREQN (tokstart, "sizeof", 6))
1568 if (STREQN (tokstart, "double", 6))
1569 return DOUBLE_KEYWORD;
1572 if (current_language->la_language == language_cplus)
1574 if (STREQN (tokstart, "false", 5))
1575 return FALSEKEYWORD;
1576 if (STREQN (tokstart, "class", 5))
1579 if (STREQN (tokstart, "union", 5))
1581 if (STREQN (tokstart, "short", 5))
1583 if (STREQN (tokstart, "const", 5))
1584 return CONST_KEYWORD;
1587 if (STREQN (tokstart, "enum", 4))
1589 if (STREQN (tokstart, "long", 4))
1591 if (current_language->la_language == language_cplus)
1593 if (STREQN (tokstart, "true", 4))
1596 if (STREQN (tokstart, "this", 4))
1598 static const char this_name[] =
1599 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1601 if (lookup_symbol (this_name, expression_context_block,
1602 VAR_NAMESPACE, (int *) NULL,
1603 (struct symtab **) NULL))
1609 if (STREQN (tokstart, "int", 3))
1616 yylval.sval.ptr = tokstart;
1617 yylval.sval.length = namelen;
1619 if (*tokstart == '$')
1621 write_dollar_variable (yylval.sval);
1625 /* Look ahead and see if we can consume more of the input
1626 string to get a reasonable class/namespace spec or a
1627 fully-qualified name. This is a kludge to get around the
1628 HP aCC compiler's generation of symbol names with embedded
1629 colons for namespace and nested classes. */
1632 /* Only do it if not inside single quotes */
1633 sym_class = parse_nested_classes_for_hpacc (yylval.sval.ptr, yylval.sval.length,
1634 &token_string, &class_prefix, &lexptr);
1637 /* Replace the current token with the bigger one we found */
1638 yylval.sval.ptr = token_string;
1639 yylval.sval.length = strlen (token_string);
1643 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1644 functions or symtabs. If this is not so, then ...
1645 Use token-type TYPENAME for symbols that happen to be defined
1646 currently as names of types; NAME for other symbols.
1647 The caller is not constrained to care about the distinction. */
1649 char *tmp = copy_name (yylval.sval);
1651 int is_a_field_of_this = 0;
1654 sym = lookup_symbol (tmp, expression_context_block,
1656 current_language->la_language == language_cplus
1657 ? &is_a_field_of_this : (int *) NULL,
1658 (struct symtab **) NULL);
1659 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1660 no psymtabs (coff, xcoff, or some future change to blow away the
1661 psymtabs once once symbols are read). */
1662 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1664 yylval.ssym.sym = sym;
1665 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1669 { /* See if it's a file name. */
1670 struct symtab *symtab;
1672 symtab = lookup_symtab (tmp);
1676 yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1681 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1684 /* Despite the following flaw, we need to keep this code enabled.
1685 Because we can get called from check_stub_method, if we don't
1686 handle nested types then it screws many operations in any
1687 program which uses nested types. */
1688 /* In "A::x", if x is a member function of A and there happens
1689 to be a type (nested or not, since the stabs don't make that
1690 distinction) named x, then this code incorrectly thinks we
1691 are dealing with nested types rather than a member function. */
1695 struct symbol *best_sym;
1697 /* Look ahead to detect nested types. This probably should be
1698 done in the grammar, but trying seemed to introduce a lot
1699 of shift/reduce and reduce/reduce conflicts. It's possible
1700 that it could be done, though. Or perhaps a non-grammar, but
1701 less ad hoc, approach would work well. */
1703 /* Since we do not currently have any way of distinguishing
1704 a nested type from a non-nested one (the stabs don't tell
1705 us whether a type is nested), we just ignore the
1712 /* Skip whitespace. */
1713 while (*p == ' ' || *p == '\t' || *p == '\n')
1715 if (*p == ':' && p[1] == ':')
1717 /* Skip the `::'. */
1719 /* Skip whitespace. */
1720 while (*p == ' ' || *p == '\t' || *p == '\n')
1723 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1724 || (*p >= 'a' && *p <= 'z')
1725 || (*p >= 'A' && *p <= 'Z'))
1729 struct symbol *cur_sym;
1730 /* As big as the whole rest of the expression, which is
1731 at least big enough. */
1732 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1736 memcpy (tmp1, tmp, strlen (tmp));
1737 tmp1 += strlen (tmp);
1738 memcpy (tmp1, "::", 2);
1740 memcpy (tmp1, namestart, p - namestart);
1741 tmp1[p - namestart] = '\0';
1742 cur_sym = lookup_symbol (ncopy, expression_context_block,
1743 VAR_NAMESPACE, (int *) NULL,
1744 (struct symtab **) NULL);
1747 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1765 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1767 yylval.tsym.type = SYMBOL_TYPE (sym);
1771 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1774 /* Input names that aren't symbols but ARE valid hex numbers,
1775 when the input radix permits them, can be names or numbers
1776 depending on the parse. Note we support radixes > 16 here. */
1778 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1779 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1781 YYSTYPE newlval; /* Its value is ignored. */
1782 hextype = parse_number (tokstart, namelen, 0, &newlval);
1785 yylval.ssym.sym = sym;
1786 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1791 /* Any other kind of symbol */
1792 yylval.ssym.sym = sym;
1793 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1803 lexptr = prev_lexptr;
1805 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);