1 /* YACC parser for Pascal expressions, for GDB.
2 Copyright (C) 2000, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 /* This file is derived from c-exp.y */
22 /* Parse a Pascal 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. */
39 /* Known bugs or limitations:
40 - pascal string operations are not supported at all.
41 - there are some problems with boolean types.
42 - Pascal type hexadecimal constants are not supported
43 because they conflict with the internal variables format.
44 Probably also lots of other problems, less well defined PM */
48 #include "gdb_string.h"
50 #include "expression.h"
52 #include "parser-defs.h"
55 #include "bfd.h" /* Required by objfiles.h. */
56 #include "symfile.h" /* Required by objfiles.h. */
57 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
60 #define parse_type builtin_type (parse_gdbarch)
62 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
63 as well as gratuitiously global symbol names, so we can have multiple
64 yacc generated parsers in gdb. Note that these are only the variables
65 produced by yacc. If other parser generators (bison, byacc, etc) produce
66 additional global names that conflict at link time, then those parser
67 generators need to be fixed instead of adding those names to this list. */
69 #define yymaxdepth pascal_maxdepth
70 #define yyparse pascal_parse
71 #define yylex pascal_lex
72 #define yyerror pascal_error
73 #define yylval pascal_lval
74 #define yychar pascal_char
75 #define yydebug pascal_debug
76 #define yypact pascal_pact
77 #define yyr1 pascal_r1
78 #define yyr2 pascal_r2
79 #define yydef pascal_def
80 #define yychk pascal_chk
81 #define yypgo pascal_pgo
82 #define yyact pascal_act
83 #define yyexca pascal_exca
84 #define yyerrflag pascal_errflag
85 #define yynerrs pascal_nerrs
86 #define yyps pascal_ps
87 #define yypv pascal_pv
89 #define yy_yys pascal_yys
90 #define yystate pascal_state
91 #define yytmp pascal_tmp
93 #define yy_yyv pascal_yyv
94 #define yyval pascal_val
95 #define yylloc pascal_lloc
96 #define yyreds pascal_reds /* With YYDEBUG defined */
97 #define yytoks pascal_toks /* With YYDEBUG defined */
98 #define yyname pascal_name /* With YYDEBUG defined */
99 #define yyrule pascal_rule /* With YYDEBUG defined */
100 #define yylhs pascal_yylhs
101 #define yylen pascal_yylen
102 #define yydefred pascal_yydefred
103 #define yydgoto pascal_yydgoto
104 #define yysindex pascal_yysindex
105 #define yyrindex pascal_yyrindex
106 #define yygindex pascal_yygindex
107 #define yytable pascal_yytable
108 #define yycheck pascal_yycheck
111 #define YYDEBUG 1 /* Default to yydebug support */
114 #define YYFPRINTF parser_fprintf
118 static int yylex (void);
123 static char * uptok (char *, int);
126 /* Although the yacc "value" of an expression is not used,
127 since the result is stored in the structure being created,
128 other node types do have values. */
145 struct symtoken ssym;
148 enum exp_opcode opcode;
149 struct internalvar *ivar;
156 /* YYSTYPE gets defined by %union */
158 parse_number (char *, int, int, YYSTYPE *);
160 static struct type *current_type;
161 static int leftdiv_is_integer;
162 static void push_current_type (void);
163 static void pop_current_type (void);
164 static int search_field;
167 %type <voidval> exp exp1 type_exp start normal_start variable qualified_name
168 %type <tval> type typebase
169 /* %type <bval> block */
171 /* Fancy type parsing. */
174 %token <typed_val_int> INT
175 %token <typed_val_float> FLOAT
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. */
186 %token <sval> FIELDNAME
187 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
188 %token <tsym> TYPENAME
190 %type <ssym> name_not_typename
192 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
193 but which would parse as a valid number in the current input radix.
194 E.g. "c" when input_radix==16. Depending on the parse, it will be
195 turned into a name or into a number. */
197 %token <ssym> NAME_OR_INT
199 %token STRUCT CLASS SIZEOF COLONCOLON
202 /* Special type cases, put in to allow the parser to distinguish different
205 %token <voidval> VARIABLE
210 %token <lval> TRUEKEYWORD FALSEKEYWORD
220 %left '<' '>' LEQ GEQ
221 %left LSH RSH DIV MOD
225 %right UNARY INCREMENT DECREMENT
226 %right ARROW '.' '[' '('
228 %token <ssym> BLOCKNAME
235 start : { current_type = NULL;
237 leftdiv_is_integer = 0;
248 { write_exp_elt_opcode(OP_TYPE);
249 write_exp_elt_type($1);
250 write_exp_elt_opcode(OP_TYPE);
251 current_type = $1; } ;
253 /* Expressions, including the comma operator. */
256 { write_exp_elt_opcode (BINOP_COMMA); }
259 /* Expressions, not including the comma operator. */
260 exp : exp '^' %prec UNARY
261 { write_exp_elt_opcode (UNOP_IND);
263 current_type = TYPE_TARGET_TYPE (current_type); }
266 exp : '@' exp %prec UNARY
267 { write_exp_elt_opcode (UNOP_ADDR);
269 current_type = TYPE_POINTER_TYPE (current_type); }
272 exp : '-' exp %prec UNARY
273 { write_exp_elt_opcode (UNOP_NEG); }
276 exp : NOT exp %prec UNARY
277 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
280 exp : INCREMENT '(' exp ')' %prec UNARY
281 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
284 exp : DECREMENT '(' exp ')' %prec UNARY
285 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
288 exp : exp '.' { search_field = 1; }
291 { write_exp_elt_opcode (STRUCTOP_STRUCT);
292 write_exp_string ($4);
293 write_exp_elt_opcode (STRUCTOP_STRUCT);
296 { while (TYPE_CODE (current_type) == TYPE_CODE_PTR)
297 current_type = TYPE_TARGET_TYPE (current_type);
298 current_type = lookup_struct_elt_type (
299 current_type, $4.ptr, 0); };
302 /* We need to save the current_type value */
305 arrayfieldindex = is_pascal_string_type (
306 current_type, NULL, NULL,
307 NULL, NULL, &arrayname);
310 struct stoken stringsval;
311 stringsval.ptr = alloca (strlen (arrayname) + 1);
312 stringsval.length = strlen (arrayname);
313 strcpy (stringsval.ptr, arrayname);
314 current_type = TYPE_FIELD_TYPE (current_type,
315 arrayfieldindex - 1);
316 write_exp_elt_opcode (STRUCTOP_STRUCT);
317 write_exp_string (stringsval);
318 write_exp_elt_opcode (STRUCTOP_STRUCT);
320 push_current_type (); }
322 { pop_current_type ();
323 write_exp_elt_opcode (BINOP_SUBSCRIPT);
325 current_type = TYPE_TARGET_TYPE (current_type); }
329 /* This is to save the value of arglist_len
330 being accumulated by an outer function call. */
331 { push_current_type ();
333 arglist ')' %prec ARROW
334 { write_exp_elt_opcode (OP_FUNCALL);
335 write_exp_elt_longcst ((LONGEST) end_arglist ());
336 write_exp_elt_opcode (OP_FUNCALL);
339 current_type = TYPE_TARGET_TYPE (current_type);
346 | arglist ',' exp %prec ABOVE_COMMA
350 exp : type '(' exp ')' %prec UNARY
353 /* Allow automatic dereference of classes. */
354 if ((TYPE_CODE (current_type) == TYPE_CODE_PTR)
355 && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS)
356 && (TYPE_CODE ($1) == TYPE_CODE_CLASS))
357 write_exp_elt_opcode (UNOP_IND);
359 write_exp_elt_opcode (UNOP_CAST);
360 write_exp_elt_type ($1);
361 write_exp_elt_opcode (UNOP_CAST);
369 /* Binary operators in order of decreasing precedence. */
372 { write_exp_elt_opcode (BINOP_MUL); }
376 if (current_type && is_integral_type (current_type))
377 leftdiv_is_integer = 1;
381 if (leftdiv_is_integer && current_type
382 && is_integral_type (current_type))
384 write_exp_elt_opcode (UNOP_CAST);
385 write_exp_elt_type (parse_type->builtin_long_double);
386 current_type = parse_type->builtin_long_double;
387 write_exp_elt_opcode (UNOP_CAST);
388 leftdiv_is_integer = 0;
391 write_exp_elt_opcode (BINOP_DIV);
396 { write_exp_elt_opcode (BINOP_INTDIV); }
400 { write_exp_elt_opcode (BINOP_REM); }
404 { write_exp_elt_opcode (BINOP_ADD); }
408 { write_exp_elt_opcode (BINOP_SUB); }
412 { write_exp_elt_opcode (BINOP_LSH); }
416 { write_exp_elt_opcode (BINOP_RSH); }
420 { write_exp_elt_opcode (BINOP_EQUAL);
421 current_type = parse_type->builtin_bool;
425 exp : exp NOTEQUAL exp
426 { write_exp_elt_opcode (BINOP_NOTEQUAL);
427 current_type = parse_type->builtin_bool;
432 { write_exp_elt_opcode (BINOP_LEQ);
433 current_type = parse_type->builtin_bool;
438 { write_exp_elt_opcode (BINOP_GEQ);
439 current_type = parse_type->builtin_bool;
444 { write_exp_elt_opcode (BINOP_LESS);
445 current_type = parse_type->builtin_bool;
450 { write_exp_elt_opcode (BINOP_GTR);
451 current_type = parse_type->builtin_bool;
456 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
460 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
464 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
468 { write_exp_elt_opcode (BINOP_ASSIGN); }
472 { write_exp_elt_opcode (OP_BOOL);
473 write_exp_elt_longcst ((LONGEST) $1);
474 current_type = parse_type->builtin_bool;
475 write_exp_elt_opcode (OP_BOOL); }
479 { write_exp_elt_opcode (OP_BOOL);
480 write_exp_elt_longcst ((LONGEST) $1);
481 current_type = parse_type->builtin_bool;
482 write_exp_elt_opcode (OP_BOOL); }
486 { write_exp_elt_opcode (OP_LONG);
487 write_exp_elt_type ($1.type);
488 current_type = $1.type;
489 write_exp_elt_longcst ((LONGEST)($1.val));
490 write_exp_elt_opcode (OP_LONG); }
495 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
496 write_exp_elt_opcode (OP_LONG);
497 write_exp_elt_type (val.typed_val_int.type);
498 current_type = val.typed_val_int.type;
499 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
500 write_exp_elt_opcode (OP_LONG);
506 { write_exp_elt_opcode (OP_DOUBLE);
507 write_exp_elt_type ($1.type);
508 current_type = $1.type;
509 write_exp_elt_dblcst ($1.dval);
510 write_exp_elt_opcode (OP_DOUBLE); }
517 /* Already written by write_dollar_variable. */
520 exp : SIZEOF '(' type ')' %prec UNARY
521 { write_exp_elt_opcode (OP_LONG);
522 write_exp_elt_type (parse_type->builtin_int);
524 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
525 write_exp_elt_opcode (OP_LONG); }
528 exp : SIZEOF '(' exp ')' %prec UNARY
529 { write_exp_elt_opcode (UNOP_SIZEOF); }
532 { /* C strings are converted into array constants with
533 an explicit null byte added at the end. Thus
534 the array upper bound is the string length.
535 There is no such thing in C as a completely empty
537 char *sp = $1.ptr; int count = $1.length;
540 write_exp_elt_opcode (OP_LONG);
541 write_exp_elt_type (parse_type->builtin_char);
542 write_exp_elt_longcst ((LONGEST)(*sp++));
543 write_exp_elt_opcode (OP_LONG);
545 write_exp_elt_opcode (OP_LONG);
546 write_exp_elt_type (parse_type->builtin_char);
547 write_exp_elt_longcst ((LONGEST)'\0');
548 write_exp_elt_opcode (OP_LONG);
549 write_exp_elt_opcode (OP_ARRAY);
550 write_exp_elt_longcst ((LONGEST) 0);
551 write_exp_elt_longcst ((LONGEST) ($1.length));
552 write_exp_elt_opcode (OP_ARRAY); }
558 struct value * this_val;
559 struct type * this_type;
560 write_exp_elt_opcode (OP_THIS);
561 write_exp_elt_opcode (OP_THIS);
562 /* we need type of this */
563 this_val = value_of_this (0);
565 this_type = value_type (this_val);
570 if (TYPE_CODE (this_type) == TYPE_CODE_PTR)
572 this_type = TYPE_TARGET_TYPE (this_type);
573 write_exp_elt_opcode (UNOP_IND);
577 current_type = this_type;
581 /* end of object pascal. */
586 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
590 lookup_symtab (copy_name ($1.stoken));
592 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
594 error ("No file or function \"%s\".",
595 copy_name ($1.stoken));
600 block : block COLONCOLON name
602 = lookup_symbol (copy_name ($3), $1,
603 VAR_DOMAIN, (int *) NULL);
604 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
605 error ("No function \"%s\" in specified context.",
607 $$ = SYMBOL_BLOCK_VALUE (tem); }
610 variable: block COLONCOLON name
611 { struct symbol *sym;
612 sym = lookup_symbol (copy_name ($3), $1,
613 VAR_DOMAIN, (int *) NULL);
615 error ("No symbol \"%s\" in specified context.",
618 write_exp_elt_opcode (OP_VAR_VALUE);
619 /* block_found is set by lookup_symbol. */
620 write_exp_elt_block (block_found);
621 write_exp_elt_sym (sym);
622 write_exp_elt_opcode (OP_VAR_VALUE); }
625 qualified_name: typebase COLONCOLON name
627 struct type *type = $1;
628 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
629 && TYPE_CODE (type) != TYPE_CODE_UNION)
630 error ("`%s' is not defined as an aggregate type.",
633 write_exp_elt_opcode (OP_SCOPE);
634 write_exp_elt_type (type);
635 write_exp_string ($3);
636 write_exp_elt_opcode (OP_SCOPE);
640 variable: qualified_name
643 char *name = copy_name ($2);
645 struct minimal_symbol *msymbol;
648 lookup_symbol (name, (const struct block *) NULL,
649 VAR_DOMAIN, (int *) NULL);
652 write_exp_elt_opcode (OP_VAR_VALUE);
653 write_exp_elt_block (NULL);
654 write_exp_elt_sym (sym);
655 write_exp_elt_opcode (OP_VAR_VALUE);
659 msymbol = lookup_minimal_symbol (name, NULL, NULL);
661 write_exp_msymbol (msymbol);
662 else 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);
689 current_type = sym->type; }
690 else if ($1.is_a_field_of_this)
692 struct value * this_val;
693 struct type * this_type;
694 /* Object pascal: it hangs off of `this'. Must
695 not inadvertently convert from a method call
697 if (innermost_block == 0
698 || contained_in (block_found,
700 innermost_block = block_found;
701 write_exp_elt_opcode (OP_THIS);
702 write_exp_elt_opcode (OP_THIS);
703 write_exp_elt_opcode (STRUCTOP_PTR);
704 write_exp_string ($1.stoken);
705 write_exp_elt_opcode (STRUCTOP_PTR);
706 /* we need type of this */
707 this_val = value_of_this (0);
709 this_type = value_type (this_val);
713 current_type = lookup_struct_elt_type (
715 copy_name ($1.stoken), 0);
721 struct minimal_symbol *msymbol;
722 char *arg = copy_name ($1.stoken);
725 lookup_minimal_symbol (arg, NULL, NULL);
727 write_exp_msymbol (msymbol);
728 else if (!have_full_symbols () && !have_partial_symbols ())
729 error ("No symbol table is loaded. Use the \"file\" command.");
731 error ("No symbol \"%s\" in current context.",
732 copy_name ($1.stoken));
741 /* We used to try to recognize more pointer to member types here, but
742 that didn't work (shift/reduce conflicts meant that these rules never
743 got executed). The problem is that
744 int (foo::bar::baz::bizzle)
745 is a function type but
746 int (foo::bar::baz::bizzle::*)
747 is a pointer to member type. Stroustrup loses again! */
752 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
754 { $$ = lookup_pointer_type ($2); }
758 { $$ = lookup_struct (copy_name ($2),
759 expression_context_block); }
761 { $$ = lookup_struct (copy_name ($2),
762 expression_context_block); }
763 /* "const" and "volatile" are curently ignored. A type qualifier
764 after the type is handled in the ptype rule. I think these could
768 name : NAME { $$ = $1.stoken; }
769 | BLOCKNAME { $$ = $1.stoken; }
770 | TYPENAME { $$ = $1.stoken; }
771 | NAME_OR_INT { $$ = $1.stoken; }
774 name_not_typename : NAME
776 /* These would be useful if name_not_typename was useful, but it is just
777 a fake for "variable", so these cause reduce/reduce conflicts because
778 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
779 =exp) or just an exp. If name_not_typename was ever used in an lvalue
780 context where only a name could occur, this might be useful.
787 /* Take care of parsing a number (anything that starts with a digit).
788 Set yylval and return the token type; update lexptr.
789 LEN is the number of characters in it. */
791 /*** Needs some error checking for the float case ***/
794 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
796 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
797 here, and we do kind of silly things like cast to unsigned. */
804 int base = input_radix;
807 /* Number of "L" suffixes encountered. */
810 /* We have found a "L" or "U" suffix. */
811 int found_suffix = 0;
814 struct type *signed_type;
815 struct type *unsigned_type;
819 if (! parse_c_float (parse_gdbarch, p, len,
820 &putithere->typed_val_float.dval,
821 &putithere->typed_val_float.type))
826 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
860 if (c >= 'A' && c <= 'Z')
862 if (c != 'l' && c != 'u')
864 if (c >= '0' && c <= '9')
872 if (base > 10 && c >= 'a' && c <= 'f')
876 n += i = c - 'a' + 10;
889 return ERROR; /* Char not a digit */
892 return ERROR; /* Invalid digit in this base */
894 /* Portably test for overflow (only works for nonzero values, so make
895 a second check for zero). FIXME: Can't we just make n and prevn
896 unsigned and avoid this? */
897 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
898 unsigned_p = 1; /* Try something unsigned */
900 /* Portably test for unsigned overflow.
901 FIXME: This check is wrong; for example it doesn't find overflow
902 on 0x123456789 when LONGEST is 32 bits. */
903 if (c != 'l' && c != 'u' && n != 0)
905 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
906 error ("Numeric constant too large.");
911 /* An integer constant is an int, a long, or a long long. An L
912 suffix forces it to be long; an LL suffix forces it to be long
913 long. If not forced to a larger size, it gets the first type of
914 the above that it fits in. To figure out whether it fits, we
915 shift it right and see whether anything remains. Note that we
916 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
917 operation, because many compilers will warn about such a shift
918 (which always produces a zero result). Sometimes gdbarch_int_bit
919 or gdbarch_long_bit will be that big, sometimes not. To deal with
920 the case where it is we just always shift the value more than
921 once, with fewer bits each time. */
923 un = (ULONGEST)n >> 2;
925 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
927 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
929 /* A large decimal (not hex or octal) constant (between INT_MAX
930 and UINT_MAX) is a long or unsigned long, according to ANSI,
931 never an unsigned int, but this code treats it as unsigned
932 int. This probably should be fixed. GCC gives a warning on
935 unsigned_type = parse_type->builtin_unsigned_int;
936 signed_type = parse_type->builtin_int;
939 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
941 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
942 unsigned_type = parse_type->builtin_unsigned_long;
943 signed_type = parse_type->builtin_long;
948 if (sizeof (ULONGEST) * HOST_CHAR_BIT
949 < gdbarch_long_long_bit (parse_gdbarch))
950 /* A long long does not fit in a LONGEST. */
951 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
953 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
954 high_bit = (ULONGEST) 1 << shift;
955 unsigned_type = parse_type->builtin_unsigned_long_long;
956 signed_type = parse_type->builtin_long_long;
959 putithere->typed_val_int.val = n;
961 /* If the high bit of the worked out type is set then this number
962 has to be unsigned. */
964 if (unsigned_p || (n & high_bit))
966 putithere->typed_val_int.type = unsigned_type;
970 putithere->typed_val_int.type = signed_type;
980 struct type_push *next;
983 static struct type_push *tp_top = NULL;
986 push_current_type (void)
988 struct type_push *tpnew;
989 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
990 tpnew->next = tp_top;
991 tpnew->stored = current_type;
997 pop_current_type (void)
999 struct type_push *tp = tp_top;
1002 current_type = tp->stored;
1012 enum exp_opcode opcode;
1015 static const struct token tokentab3[] =
1017 {"shr", RSH, BINOP_END},
1018 {"shl", LSH, BINOP_END},
1019 {"and", ANDAND, BINOP_END},
1020 {"div", DIV, BINOP_END},
1021 {"not", NOT, BINOP_END},
1022 {"mod", MOD, BINOP_END},
1023 {"inc", INCREMENT, BINOP_END},
1024 {"dec", DECREMENT, BINOP_END},
1025 {"xor", XOR, BINOP_END}
1028 static const struct token tokentab2[] =
1030 {"or", OR, BINOP_END},
1031 {"<>", NOTEQUAL, BINOP_END},
1032 {"<=", LEQ, BINOP_END},
1033 {">=", GEQ, BINOP_END},
1034 {":=", ASSIGN, BINOP_END},
1035 {"::", COLONCOLON, BINOP_END} };
1037 /* Allocate uppercased var */
1038 /* make an uppercased copy of tokstart */
1039 static char * uptok (tokstart, namelen)
1044 char *uptokstart = (char *)malloc(namelen+1);
1045 for (i = 0;i <= namelen;i++)
1047 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1048 uptokstart[i] = tokstart[i]-('a'-'A');
1050 uptokstart[i] = tokstart[i];
1052 uptokstart[namelen]='\0';
1055 /* Read one token, getting characters through lexptr. */
1067 int explen, tempbufindex;
1068 static char *tempbuf;
1069 static int tempbufsize;
1073 prev_lexptr = lexptr;
1076 explen = strlen (lexptr);
1077 /* See if it is a special token of length 3. */
1079 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1080 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0
1081 && (!isalpha (tokentab3[i].operator[0]) || explen == 3
1082 || (!isalpha (tokstart[3]) && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1085 yylval.opcode = tokentab3[i].opcode;
1086 return tokentab3[i].token;
1089 /* See if it is a special token of length 2. */
1091 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1092 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0
1093 && (!isalpha (tokentab2[i].operator[0]) || explen == 2
1094 || (!isalpha (tokstart[2]) && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1097 yylval.opcode = tokentab2[i].opcode;
1098 return tokentab2[i].token;
1101 switch (c = *tokstart)
1113 /* We either have a character constant ('0' or '\177' for example)
1114 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1119 c = parse_escape (parse_gdbarch, &lexptr);
1121 error ("Empty character constant.");
1123 yylval.typed_val_int.val = c;
1124 yylval.typed_val_int.type = parse_type->builtin_char;
1129 namelen = skip_quoted (tokstart) - tokstart;
1132 lexptr = tokstart + namelen;
1133 if (lexptr[-1] != '\'')
1134 error ("Unmatched single quote.");
1137 uptokstart = uptok(tokstart,namelen);
1140 error ("Invalid character constant.");
1150 if (paren_depth == 0)
1157 if (comma_terminates && paren_depth == 0)
1163 /* Might be a floating point number. */
1164 if (lexptr[1] < '0' || lexptr[1] > '9')
1165 goto symbol; /* Nope, must be a symbol. */
1166 /* FALL THRU into number case. */
1179 /* It's a number. */
1180 int got_dot = 0, got_e = 0, toktype;
1182 int hex = input_radix > 10;
1184 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1189 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1197 /* This test includes !hex because 'e' is a valid hex digit
1198 and thus does not indicate a floating point number when
1199 the radix is hex. */
1200 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1201 got_dot = got_e = 1;
1202 /* This test does not include !hex, because a '.' always indicates
1203 a decimal floating point number regardless of the radix. */
1204 else if (!got_dot && *p == '.')
1206 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1207 && (*p == '-' || *p == '+'))
1208 /* This is the sign of the exponent, not the end of the
1211 /* We will take any letters or digits. parse_number will
1212 complain if past the radix, or if L or U are not final. */
1213 else if ((*p < '0' || *p > '9')
1214 && ((*p < 'a' || *p > 'z')
1215 && (*p < 'A' || *p > 'Z')))
1218 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1219 if (toktype == ERROR)
1221 char *err_copy = (char *) alloca (p - tokstart + 1);
1223 memcpy (err_copy, tokstart, p - tokstart);
1224 err_copy[p - tokstart] = 0;
1225 error ("Invalid number \"%s\".", err_copy);
1256 /* Build the gdb internal form of the input string in tempbuf,
1257 translating any standard C escape forms seen. Note that the
1258 buffer is null byte terminated *only* for the convenience of
1259 debugging gdb itself and printing the buffer contents when
1260 the buffer contains no embedded nulls. Gdb does not depend
1261 upon the buffer being null byte terminated, it uses the length
1262 string instead. This allows gdb to handle C strings (as well
1263 as strings in other languages) with embedded null bytes */
1265 tokptr = ++tokstart;
1269 /* Grow the static temp buffer if necessary, including allocating
1270 the first one on demand. */
1271 if (tempbufindex + 1 >= tempbufsize)
1273 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1280 /* Do nothing, loop will terminate. */
1284 c = parse_escape (parse_gdbarch, &tokptr);
1289 tempbuf[tempbufindex++] = c;
1292 tempbuf[tempbufindex++] = *tokptr++;
1295 } while ((*tokptr != '"') && (*tokptr != '\0'));
1296 if (*tokptr++ != '"')
1298 error ("Unterminated string in expression.");
1300 tempbuf[tempbufindex] = '\0'; /* See note above */
1301 yylval.sval.ptr = tempbuf;
1302 yylval.sval.length = tempbufindex;
1307 if (!(c == '_' || c == '$'
1308 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1309 /* We must have come across a bad character (e.g. ';'). */
1310 error ("Invalid character '%c' in expression.", c);
1312 /* It's a name. See how long it is. */
1314 for (c = tokstart[namelen];
1315 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1316 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1318 /* Template parameter lists are part of the name.
1319 FIXME: This mishandles `print $a<4&&$a>3'. */
1323 int nesting_level = 1;
1324 while (tokstart[++i])
1326 if (tokstart[i] == '<')
1328 else if (tokstart[i] == '>')
1330 if (--nesting_level == 0)
1334 if (tokstart[i] == '>')
1340 /* do NOT uppercase internals because of registers !!! */
1341 c = tokstart[++namelen];
1344 uptokstart = uptok(tokstart,namelen);
1346 /* The token "if" terminates the expression and is NOT
1347 removed from the input stream. */
1348 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1358 /* Catch specific keywords. Should be done with a data structure. */
1362 if (strcmp (uptokstart, "OBJECT") == 0)
1367 if (strcmp (uptokstart, "RECORD") == 0)
1372 if (strcmp (uptokstart, "SIZEOF") == 0)
1379 if (strcmp (uptokstart, "CLASS") == 0)
1384 if (strcmp (uptokstart, "FALSE") == 0)
1388 return FALSEKEYWORD;
1392 if (strcmp (uptokstart, "TRUE") == 0)
1398 if (strcmp (uptokstart, "SELF") == 0)
1400 /* here we search for 'this' like
1401 inserted in FPC stabs debug info */
1402 static const char this_name[] = "this";
1404 if (lookup_symbol (this_name, expression_context_block,
1405 VAR_DOMAIN, (int *) NULL))
1416 yylval.sval.ptr = tokstart;
1417 yylval.sval.length = namelen;
1419 if (*tokstart == '$')
1421 /* $ is the normal prefix for pascal hexadecimal values
1422 but this conflicts with the GDB use for debugger variables
1423 so in expression to enter hexadecimal values
1424 we still need to use C syntax with 0xff */
1425 write_dollar_variable (yylval.sval);
1430 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1431 functions or symtabs. If this is not so, then ...
1432 Use token-type TYPENAME for symbols that happen to be defined
1433 currently as names of types; NAME for other symbols.
1434 The caller is not constrained to care about the distinction. */
1436 char *tmp = copy_name (yylval.sval);
1438 int is_a_field_of_this = 0;
1443 if (search_field && current_type)
1444 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1448 sym = lookup_symbol (tmp, expression_context_block,
1449 VAR_DOMAIN, &is_a_field_of_this);
1450 /* second chance uppercased (as Free Pascal does). */
1451 if (!sym && !is_a_field_of_this && !is_a_field)
1453 for (i = 0; i <= namelen; i++)
1455 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1456 tmp[i] -= ('a'-'A');
1458 if (search_field && current_type)
1459 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1463 sym = lookup_symbol (tmp, expression_context_block,
1464 VAR_DOMAIN, &is_a_field_of_this);
1465 if (sym || is_a_field_of_this || is_a_field)
1466 for (i = 0; i <= namelen; i++)
1468 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1469 tokstart[i] -= ('a'-'A');
1472 /* Third chance Capitalized (as GPC does). */
1473 if (!sym && !is_a_field_of_this && !is_a_field)
1475 for (i = 0; i <= namelen; i++)
1479 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1480 tmp[i] -= ('a'-'A');
1483 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1484 tmp[i] -= ('A'-'a');
1486 if (search_field && current_type)
1487 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1491 sym = lookup_symbol (tmp, expression_context_block,
1492 VAR_DOMAIN, &is_a_field_of_this);
1493 if (sym || is_a_field_of_this || is_a_field)
1494 for (i = 0; i <= namelen; i++)
1498 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1499 tokstart[i] -= ('a'-'A');
1502 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
1503 tokstart[i] -= ('A'-'a');
1509 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1510 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
1511 yylval.sval.ptr = tempbuf;
1512 yylval.sval.length = namelen;
1516 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1517 no psymtabs (coff, xcoff, or some future change to blow away the
1518 psymtabs once once symbols are read). */
1519 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1520 || lookup_symtab (tmp))
1522 yylval.ssym.sym = sym;
1523 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1527 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1530 /* Despite the following flaw, we need to keep this code enabled.
1531 Because we can get called from check_stub_method, if we don't
1532 handle nested types then it screws many operations in any
1533 program which uses nested types. */
1534 /* In "A::x", if x is a member function of A and there happens
1535 to be a type (nested or not, since the stabs don't make that
1536 distinction) named x, then this code incorrectly thinks we
1537 are dealing with nested types rather than a member function. */
1541 struct symbol *best_sym;
1543 /* Look ahead to detect nested types. This probably should be
1544 done in the grammar, but trying seemed to introduce a lot
1545 of shift/reduce and reduce/reduce conflicts. It's possible
1546 that it could be done, though. Or perhaps a non-grammar, but
1547 less ad hoc, approach would work well. */
1549 /* Since we do not currently have any way of distinguishing
1550 a nested type from a non-nested one (the stabs don't tell
1551 us whether a type is nested), we just ignore the
1558 /* Skip whitespace. */
1559 while (*p == ' ' || *p == '\t' || *p == '\n')
1561 if (*p == ':' && p[1] == ':')
1563 /* Skip the `::'. */
1565 /* Skip whitespace. */
1566 while (*p == ' ' || *p == '\t' || *p == '\n')
1569 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1570 || (*p >= 'a' && *p <= 'z')
1571 || (*p >= 'A' && *p <= 'Z'))
1575 struct symbol *cur_sym;
1576 /* As big as the whole rest of the expression, which is
1577 at least big enough. */
1578 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1582 memcpy (tmp1, tmp, strlen (tmp));
1583 tmp1 += strlen (tmp);
1584 memcpy (tmp1, "::", 2);
1586 memcpy (tmp1, namestart, p - namestart);
1587 tmp1[p - namestart] = '\0';
1588 cur_sym = lookup_symbol (ncopy, expression_context_block,
1589 VAR_DOMAIN, (int *) NULL);
1592 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1610 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1612 yylval.tsym.type = SYMBOL_TYPE (sym);
1618 = language_lookup_primitive_type_by_name (parse_language,
1619 parse_gdbarch, tmp);
1620 if (yylval.tsym.type != NULL)
1626 /* Input names that aren't symbols but ARE valid hex numbers,
1627 when the input radix permits them, can be names or numbers
1628 depending on the parse. Note we support radixes > 16 here. */
1630 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1631 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1633 YYSTYPE newlval; /* Its value is ignored. */
1634 hextype = parse_number (tokstart, namelen, 0, &newlval);
1637 yylval.ssym.sym = sym;
1638 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1645 /* Any other kind of symbol */
1646 yylval.ssym.sym = sym;
1647 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1657 lexptr = prev_lexptr;
1659 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);