1 /* YACC parser for Pascal expressions, for GDB.
2 Copyright (C) 2000, 2006, 2007 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
21 /* This file is derived from c-exp.y */
23 /* Parse a Pascal 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. */
40 /* Known bugs or limitations:
41 - pascal string operations are not supported at all.
42 - there are some problems with boolean types.
43 - Pascal type hexadecimal constants are not supported
44 because they conflict with the internal variables format.
45 Probably also lots of other problems, less well defined PM */
49 #include "gdb_string.h"
51 #include "expression.h"
53 #include "parser-defs.h"
56 #include "bfd.h" /* Required by objfiles.h. */
57 #include "symfile.h" /* Required by objfiles.h. */
58 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
62 as well as gratuitiously global symbol names, so we can have multiple
63 yacc generated parsers in gdb. Note that these are only the variables
64 produced by yacc. If other parser generators (bison, byacc, etc) produce
65 additional global names that conflict at link time, then those parser
66 generators need to be fixed instead of adding those names to this list. */
68 #define yymaxdepth pascal_maxdepth
69 #define yyparse pascal_parse
70 #define yylex pascal_lex
71 #define yyerror pascal_error
72 #define yylval pascal_lval
73 #define yychar pascal_char
74 #define yydebug pascal_debug
75 #define yypact pascal_pact
76 #define yyr1 pascal_r1
77 #define yyr2 pascal_r2
78 #define yydef pascal_def
79 #define yychk pascal_chk
80 #define yypgo pascal_pgo
81 #define yyact pascal_act
82 #define yyexca pascal_exca
83 #define yyerrflag pascal_errflag
84 #define yynerrs pascal_nerrs
85 #define yyps pascal_ps
86 #define yypv pascal_pv
88 #define yy_yys pascal_yys
89 #define yystate pascal_state
90 #define yytmp pascal_tmp
92 #define yy_yyv pascal_yyv
93 #define yyval pascal_val
94 #define yylloc pascal_lloc
95 #define yyreds pascal_reds /* With YYDEBUG defined */
96 #define yytoks pascal_toks /* With YYDEBUG defined */
97 #define yyname pascal_name /* With YYDEBUG defined */
98 #define yyrule pascal_rule /* With YYDEBUG defined */
99 #define yylhs pascal_yylhs
100 #define yylen pascal_yylen
101 #define yydefred pascal_yydefred
102 #define yydgoto pascal_yydgoto
103 #define yysindex pascal_yysindex
104 #define yyrindex pascal_yyrindex
105 #define yygindex pascal_yygindex
106 #define yytable pascal_yytable
107 #define yycheck pascal_yycheck
110 #define YYDEBUG 1 /* Default to yydebug support */
113 #define YYFPRINTF parser_fprintf
117 static int yylex (void);
122 static char * uptok (char *, int);
125 /* Although the yacc "value" of an expression is not used,
126 since the result is stored in the structure being created,
127 other node types do have values. */
144 struct symtoken ssym;
147 enum exp_opcode opcode;
148 struct internalvar *ivar;
155 /* YYSTYPE gets defined by %union */
157 parse_number (char *, int, int, YYSTYPE *);
159 static struct type *current_type;
161 static void push_current_type (void);
162 static void pop_current_type (void);
163 static int search_field;
166 %type <voidval> exp exp1 type_exp start normal_start variable qualified_name
167 %type <tval> type typebase
168 /* %type <bval> block */
170 /* Fancy type parsing. */
173 %token <typed_val_int> INT
174 %token <typed_val_float> FLOAT
176 /* Both NAME and TYPENAME tokens represent symbols in the input,
177 and both convey their data as strings.
178 But a TYPENAME is a string that happens to be defined as a typedef
179 or builtin type name (such as int or char)
180 and a NAME is any other symbol.
181 Contexts where this distinction is not important can use the
182 nonterminal "name", which matches either NAME or TYPENAME. */
185 %token <sval> FIELDNAME
186 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
187 %token <tsym> TYPENAME
189 %type <ssym> name_not_typename
191 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
192 but which would parse as a valid number in the current input radix.
193 E.g. "c" when input_radix==16. Depending on the parse, it will be
194 turned into a name or into a number. */
196 %token <ssym> NAME_OR_INT
198 %token STRUCT CLASS SIZEOF COLONCOLON
201 /* Special type cases, put in to allow the parser to distinguish different
204 %token <voidval> VARIABLE
209 %token <lval> TRUEKEYWORD FALSEKEYWORD
219 %left '<' '>' LEQ GEQ
220 %left LSH RSH DIV MOD
224 %right UNARY INCREMENT DECREMENT
225 %right ARROW '.' '[' '('
227 %token <ssym> BLOCKNAME
234 start : { current_type = NULL;
246 { write_exp_elt_opcode(OP_TYPE);
247 write_exp_elt_type($1);
248 write_exp_elt_opcode(OP_TYPE);
249 current_type = $1; } ;
251 /* Expressions, including the comma operator. */
254 { write_exp_elt_opcode (BINOP_COMMA); }
257 /* Expressions, not including the comma operator. */
258 exp : exp '^' %prec UNARY
259 { write_exp_elt_opcode (UNOP_IND);
261 current_type = TYPE_TARGET_TYPE (current_type); }
264 exp : '@' exp %prec UNARY
265 { write_exp_elt_opcode (UNOP_ADDR);
267 current_type = TYPE_POINTER_TYPE (current_type); }
270 exp : '-' exp %prec UNARY
271 { write_exp_elt_opcode (UNOP_NEG); }
274 exp : NOT exp %prec UNARY
275 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
278 exp : INCREMENT '(' exp ')' %prec UNARY
279 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
282 exp : DECREMENT '(' exp ')' %prec UNARY
283 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
286 exp : exp '.' { search_field = 1; }
289 { write_exp_elt_opcode (STRUCTOP_STRUCT);
290 write_exp_string ($4);
291 write_exp_elt_opcode (STRUCTOP_STRUCT);
294 { while (TYPE_CODE (current_type) == TYPE_CODE_PTR)
295 current_type = TYPE_TARGET_TYPE (current_type);
296 current_type = lookup_struct_elt_type (
297 current_type, $4.ptr, 0); };
300 /* We need to save the current_type value */
303 arrayfieldindex = is_pascal_string_type (
304 current_type, NULL, NULL,
305 NULL, NULL, &arrayname);
308 struct stoken stringsval;
309 stringsval.ptr = alloca (strlen (arrayname) + 1);
310 stringsval.length = strlen (arrayname);
311 strcpy (stringsval.ptr, arrayname);
312 current_type = TYPE_FIELD_TYPE (current_type,
313 arrayfieldindex - 1);
314 write_exp_elt_opcode (STRUCTOP_STRUCT);
315 write_exp_string (stringsval);
316 write_exp_elt_opcode (STRUCTOP_STRUCT);
318 push_current_type (); }
320 { pop_current_type ();
321 write_exp_elt_opcode (BINOP_SUBSCRIPT);
323 current_type = TYPE_TARGET_TYPE (current_type); }
327 /* This is to save the value of arglist_len
328 being accumulated by an outer function call. */
329 { push_current_type ();
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);
335 pop_current_type (); }
341 | arglist ',' exp %prec ABOVE_COMMA
345 exp : type '(' exp ')' %prec UNARY
348 /* Allow automatic dereference of classes. */
349 if ((TYPE_CODE (current_type) == TYPE_CODE_PTR)
350 && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS)
351 && (TYPE_CODE ($1) == TYPE_CODE_CLASS))
352 write_exp_elt_opcode (UNOP_IND);
354 write_exp_elt_opcode (UNOP_CAST);
355 write_exp_elt_type ($1);
356 write_exp_elt_opcode (UNOP_CAST);
364 /* Binary operators in order of decreasing precedence. */
367 { write_exp_elt_opcode (BINOP_MUL); }
371 { write_exp_elt_opcode (BINOP_DIV); }
375 { write_exp_elt_opcode (BINOP_INTDIV); }
379 { write_exp_elt_opcode (BINOP_REM); }
383 { write_exp_elt_opcode (BINOP_ADD); }
387 { write_exp_elt_opcode (BINOP_SUB); }
391 { write_exp_elt_opcode (BINOP_LSH); }
395 { write_exp_elt_opcode (BINOP_RSH); }
399 { write_exp_elt_opcode (BINOP_EQUAL); }
402 exp : exp NOTEQUAL exp
403 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
407 { write_exp_elt_opcode (BINOP_LEQ); }
411 { write_exp_elt_opcode (BINOP_GEQ); }
415 { write_exp_elt_opcode (BINOP_LESS); }
419 { write_exp_elt_opcode (BINOP_GTR); }
423 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
427 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
431 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
435 { write_exp_elt_opcode (BINOP_ASSIGN); }
439 { write_exp_elt_opcode (OP_BOOL);
440 write_exp_elt_longcst ((LONGEST) $1);
441 write_exp_elt_opcode (OP_BOOL); }
445 { write_exp_elt_opcode (OP_BOOL);
446 write_exp_elt_longcst ((LONGEST) $1);
447 write_exp_elt_opcode (OP_BOOL); }
451 { write_exp_elt_opcode (OP_LONG);
452 write_exp_elt_type ($1.type);
453 write_exp_elt_longcst ((LONGEST)($1.val));
454 write_exp_elt_opcode (OP_LONG); }
459 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
460 write_exp_elt_opcode (OP_LONG);
461 write_exp_elt_type (val.typed_val_int.type);
462 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
463 write_exp_elt_opcode (OP_LONG);
469 { write_exp_elt_opcode (OP_DOUBLE);
470 write_exp_elt_type ($1.type);
471 write_exp_elt_dblcst ($1.dval);
472 write_exp_elt_opcode (OP_DOUBLE); }
479 /* Already written by write_dollar_variable. */
482 exp : SIZEOF '(' type ')' %prec UNARY
483 { write_exp_elt_opcode (OP_LONG);
484 write_exp_elt_type (builtin_type_int);
486 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
487 write_exp_elt_opcode (OP_LONG); }
491 { /* C strings are converted into array constants with
492 an explicit null byte added at the end. Thus
493 the array upper bound is the string length.
494 There is no such thing in C as a completely empty
496 char *sp = $1.ptr; int count = $1.length;
499 write_exp_elt_opcode (OP_LONG);
500 write_exp_elt_type (builtin_type_char);
501 write_exp_elt_longcst ((LONGEST)(*sp++));
502 write_exp_elt_opcode (OP_LONG);
504 write_exp_elt_opcode (OP_LONG);
505 write_exp_elt_type (builtin_type_char);
506 write_exp_elt_longcst ((LONGEST)'\0');
507 write_exp_elt_opcode (OP_LONG);
508 write_exp_elt_opcode (OP_ARRAY);
509 write_exp_elt_longcst ((LONGEST) 0);
510 write_exp_elt_longcst ((LONGEST) ($1.length));
511 write_exp_elt_opcode (OP_ARRAY); }
517 struct value * this_val;
518 struct type * this_type;
519 write_exp_elt_opcode (OP_THIS);
520 write_exp_elt_opcode (OP_THIS);
521 /* we need type of this */
522 this_val = value_of_this (0);
524 this_type = value_type (this_val);
529 if (TYPE_CODE (this_type) == TYPE_CODE_PTR)
531 this_type = TYPE_TARGET_TYPE (this_type);
532 write_exp_elt_opcode (UNOP_IND);
536 current_type = this_type;
540 /* end of object pascal. */
545 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
549 lookup_symtab (copy_name ($1.stoken));
551 $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK);
553 error ("No file or function \"%s\".",
554 copy_name ($1.stoken));
559 block : block COLONCOLON name
561 = lookup_symbol (copy_name ($3), $1,
562 VAR_DOMAIN, (int *) NULL,
563 (struct symtab **) NULL);
564 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
565 error ("No function \"%s\" in specified context.",
567 $$ = SYMBOL_BLOCK_VALUE (tem); }
570 variable: block COLONCOLON name
571 { struct symbol *sym;
572 sym = lookup_symbol (copy_name ($3), $1,
573 VAR_DOMAIN, (int *) NULL,
574 (struct symtab **) NULL);
576 error ("No symbol \"%s\" in specified context.",
579 write_exp_elt_opcode (OP_VAR_VALUE);
580 /* block_found is set by lookup_symbol. */
581 write_exp_elt_block (block_found);
582 write_exp_elt_sym (sym);
583 write_exp_elt_opcode (OP_VAR_VALUE); }
586 qualified_name: typebase COLONCOLON name
588 struct type *type = $1;
589 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
590 && TYPE_CODE (type) != TYPE_CODE_UNION)
591 error ("`%s' is not defined as an aggregate type.",
594 write_exp_elt_opcode (OP_SCOPE);
595 write_exp_elt_type (type);
596 write_exp_string ($3);
597 write_exp_elt_opcode (OP_SCOPE);
601 variable: qualified_name
604 char *name = copy_name ($2);
606 struct minimal_symbol *msymbol;
609 lookup_symbol (name, (const struct block *) NULL,
610 VAR_DOMAIN, (int *) NULL,
611 (struct symtab **) NULL);
614 write_exp_elt_opcode (OP_VAR_VALUE);
615 write_exp_elt_block (NULL);
616 write_exp_elt_sym (sym);
617 write_exp_elt_opcode (OP_VAR_VALUE);
621 msymbol = lookup_minimal_symbol (name, NULL, NULL);
624 write_exp_msymbol (msymbol,
625 lookup_function_type (builtin_type_int),
629 if (!have_full_symbols () && !have_partial_symbols ())
630 error ("No symbol table is loaded. Use the \"file\" command.");
632 error ("No symbol \"%s\" in current context.", name);
636 variable: name_not_typename
637 { struct symbol *sym = $1.sym;
641 if (symbol_read_needs_frame (sym))
643 if (innermost_block == 0 ||
644 contained_in (block_found,
646 innermost_block = block_found;
649 write_exp_elt_opcode (OP_VAR_VALUE);
650 /* We want to use the selected frame, not
651 another more inner frame which happens to
652 be in the same block. */
653 write_exp_elt_block (NULL);
654 write_exp_elt_sym (sym);
655 write_exp_elt_opcode (OP_VAR_VALUE);
656 current_type = sym->type; }
657 else if ($1.is_a_field_of_this)
659 struct value * this_val;
660 struct type * this_type;
661 /* Object pascal: it hangs off of `this'. Must
662 not inadvertently convert from a method call
664 if (innermost_block == 0 ||
665 contained_in (block_found, innermost_block))
666 innermost_block = block_found;
667 write_exp_elt_opcode (OP_THIS);
668 write_exp_elt_opcode (OP_THIS);
669 write_exp_elt_opcode (STRUCTOP_PTR);
670 write_exp_string ($1.stoken);
671 write_exp_elt_opcode (STRUCTOP_PTR);
672 /* we need type of this */
673 this_val = value_of_this (0);
675 this_type = value_type (this_val);
679 current_type = lookup_struct_elt_type (
681 copy_name ($1.stoken), 0);
687 struct minimal_symbol *msymbol;
688 char *arg = copy_name ($1.stoken);
691 lookup_minimal_symbol (arg, NULL, NULL);
694 write_exp_msymbol (msymbol,
695 lookup_function_type (builtin_type_int),
698 else if (!have_full_symbols () && !have_partial_symbols ())
699 error ("No symbol table is loaded. Use the \"file\" command.");
701 error ("No symbol \"%s\" in current context.",
702 copy_name ($1.stoken));
711 /* We used to try to recognize more pointer to member types here, but
712 that didn't work (shift/reduce conflicts meant that these rules never
713 got executed). The problem is that
714 int (foo::bar::baz::bizzle)
715 is a function type but
716 int (foo::bar::baz::bizzle::*)
717 is a pointer to member type. Stroustrup loses again! */
722 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
724 { $$ = lookup_pointer_type ($2); }
728 { $$ = lookup_struct (copy_name ($2),
729 expression_context_block); }
731 { $$ = lookup_struct (copy_name ($2),
732 expression_context_block); }
733 /* "const" and "volatile" are curently ignored. A type qualifier
734 after the type is handled in the ptype rule. I think these could
738 name : NAME { $$ = $1.stoken; }
739 | BLOCKNAME { $$ = $1.stoken; }
740 | TYPENAME { $$ = $1.stoken; }
741 | NAME_OR_INT { $$ = $1.stoken; }
744 name_not_typename : NAME
746 /* These would be useful if name_not_typename was useful, but it is just
747 a fake for "variable", so these cause reduce/reduce conflicts because
748 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
749 =exp) or just an exp. If name_not_typename was ever used in an lvalue
750 context where only a name could occur, this might be useful.
757 /* Take care of parsing a number (anything that starts with a digit).
758 Set yylval and return the token type; update lexptr.
759 LEN is the number of characters in it. */
761 /*** Needs some error checking for the float case ***/
764 parse_number (p, len, parsed_float, putithere)
770 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
771 here, and we do kind of silly things like cast to unsigned. */
778 int base = input_radix;
781 /* Number of "L" suffixes encountered. */
784 /* We have found a "L" or "U" suffix. */
785 int found_suffix = 0;
788 struct type *signed_type;
789 struct type *unsigned_type;
793 /* It's a float since it contains a point or an exponent. */
795 int num = 0; /* number of tokens scanned by scanf */
796 char saved_char = p[len];
798 p[len] = 0; /* null-terminate the token */
799 num = sscanf (p, DOUBLEST_SCAN_FORMAT "%c",
800 &putithere->typed_val_float.dval, &c);
801 p[len] = saved_char; /* restore the input stream */
802 if (num != 1) /* check scanf found ONLY a float ... */
804 /* See if it has `f' or `l' suffix (float or long double). */
806 c = tolower (p[len - 1]);
809 putithere->typed_val_float.type = builtin_type_float;
811 putithere->typed_val_float.type = builtin_type_long_double;
812 else if (isdigit (c) || c == '.')
813 putithere->typed_val_float.type = builtin_type_double;
820 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
854 if (c >= 'A' && c <= 'Z')
856 if (c != 'l' && c != 'u')
858 if (c >= '0' && c <= '9')
866 if (base > 10 && c >= 'a' && c <= 'f')
870 n += i = c - 'a' + 10;
883 return ERROR; /* Char not a digit */
886 return ERROR; /* Invalid digit in this base */
888 /* Portably test for overflow (only works for nonzero values, so make
889 a second check for zero). FIXME: Can't we just make n and prevn
890 unsigned and avoid this? */
891 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
892 unsigned_p = 1; /* Try something unsigned */
894 /* Portably test for unsigned overflow.
895 FIXME: This check is wrong; for example it doesn't find overflow
896 on 0x123456789 when LONGEST is 32 bits. */
897 if (c != 'l' && c != 'u' && n != 0)
899 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
900 error ("Numeric constant too large.");
905 /* An integer constant is an int, a long, or a long long. An L
906 suffix forces it to be long; an LL suffix forces it to be long
907 long. If not forced to a larger size, it gets the first type of
908 the above that it fits in. To figure out whether it fits, we
909 shift it right and see whether anything remains. Note that we
910 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
911 operation, because many compilers will warn about such a shift
912 (which always produces a zero result). Sometimes TARGET_INT_BIT
913 or TARGET_LONG_BIT will be that big, sometimes not. To deal with
914 the case where it is we just always shift the value more than
915 once, with fewer bits each time. */
917 un = (ULONGEST)n >> 2;
919 && (un >> (TARGET_INT_BIT - 2)) == 0)
921 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
923 /* A large decimal (not hex or octal) constant (between INT_MAX
924 and UINT_MAX) is a long or unsigned long, according to ANSI,
925 never an unsigned int, but this code treats it as unsigned
926 int. This probably should be fixed. GCC gives a warning on
929 unsigned_type = builtin_type_unsigned_int;
930 signed_type = builtin_type_int;
933 && (un >> (TARGET_LONG_BIT - 2)) == 0)
935 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
936 unsigned_type = builtin_type_unsigned_long;
937 signed_type = builtin_type_long;
942 if (sizeof (ULONGEST) * HOST_CHAR_BIT < TARGET_LONG_LONG_BIT)
943 /* A long long does not fit in a LONGEST. */
944 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
946 shift = (TARGET_LONG_LONG_BIT - 1);
947 high_bit = (ULONGEST) 1 << shift;
948 unsigned_type = builtin_type_unsigned_long_long;
949 signed_type = builtin_type_long_long;
952 putithere->typed_val_int.val = n;
954 /* If the high bit of the worked out type is set then this number
955 has to be unsigned. */
957 if (unsigned_p || (n & high_bit))
959 putithere->typed_val_int.type = unsigned_type;
963 putithere->typed_val_int.type = signed_type;
973 struct type_push *next;
976 static struct type_push *tp_top = NULL;
979 push_current_type (void)
981 struct type_push *tpnew;
982 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
983 tpnew->next = tp_top;
984 tpnew->stored = current_type;
990 pop_current_type (void)
992 struct type_push *tp = tp_top;
995 current_type = tp->stored;
1005 enum exp_opcode opcode;
1008 static const struct token tokentab3[] =
1010 {"shr", RSH, BINOP_END},
1011 {"shl", LSH, BINOP_END},
1012 {"and", ANDAND, BINOP_END},
1013 {"div", DIV, BINOP_END},
1014 {"not", NOT, BINOP_END},
1015 {"mod", MOD, BINOP_END},
1016 {"inc", INCREMENT, BINOP_END},
1017 {"dec", DECREMENT, BINOP_END},
1018 {"xor", XOR, BINOP_END}
1021 static const struct token tokentab2[] =
1023 {"or", OR, BINOP_END},
1024 {"<>", NOTEQUAL, BINOP_END},
1025 {"<=", LEQ, BINOP_END},
1026 {">=", GEQ, BINOP_END},
1027 {":=", ASSIGN, BINOP_END},
1028 {"::", COLONCOLON, BINOP_END} };
1030 /* Allocate uppercased var */
1031 /* make an uppercased copy of tokstart */
1032 static char * uptok (tokstart, namelen)
1037 char *uptokstart = (char *)malloc(namelen+1);
1038 for (i = 0;i <= namelen;i++)
1040 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1041 uptokstart[i] = tokstart[i]-('a'-'A');
1043 uptokstart[i] = tokstart[i];
1045 uptokstart[namelen]='\0';
1048 /* Read one token, getting characters through lexptr. */
1061 int explen, tempbufindex;
1062 static char *tempbuf;
1063 static int tempbufsize;
1067 prev_lexptr = lexptr;
1070 explen = strlen (lexptr);
1071 /* See if it is a special token of length 3. */
1073 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1074 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0
1075 && (!isalpha (tokentab3[i].operator[0]) || explen == 3
1076 || (!isalpha (tokstart[3]) && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1079 yylval.opcode = tokentab3[i].opcode;
1080 return tokentab3[i].token;
1083 /* See if it is a special token of length 2. */
1085 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1086 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0
1087 && (!isalpha (tokentab2[i].operator[0]) || explen == 2
1088 || (!isalpha (tokstart[2]) && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1091 yylval.opcode = tokentab2[i].opcode;
1092 return tokentab2[i].token;
1095 switch (c = *tokstart)
1107 /* We either have a character constant ('0' or '\177' for example)
1108 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1113 c = parse_escape (&lexptr);
1115 error ("Empty character constant.");
1117 yylval.typed_val_int.val = c;
1118 yylval.typed_val_int.type = builtin_type_char;
1123 namelen = skip_quoted (tokstart) - tokstart;
1126 lexptr = tokstart + namelen;
1127 if (lexptr[-1] != '\'')
1128 error ("Unmatched single quote.");
1131 uptokstart = uptok(tokstart,namelen);
1134 error ("Invalid character constant.");
1144 if (paren_depth == 0)
1151 if (comma_terminates && paren_depth == 0)
1157 /* Might be a floating point number. */
1158 if (lexptr[1] < '0' || lexptr[1] > '9')
1159 goto symbol; /* Nope, must be a symbol. */
1160 /* FALL THRU into number case. */
1173 /* It's a number. */
1174 int got_dot = 0, got_e = 0, toktype;
1176 int hex = input_radix > 10;
1178 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1183 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1191 /* This test includes !hex because 'e' is a valid hex digit
1192 and thus does not indicate a floating point number when
1193 the radix is hex. */
1194 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1195 got_dot = got_e = 1;
1196 /* This test does not include !hex, because a '.' always indicates
1197 a decimal floating point number regardless of the radix. */
1198 else if (!got_dot && *p == '.')
1200 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1201 && (*p == '-' || *p == '+'))
1202 /* This is the sign of the exponent, not the end of the
1205 /* We will take any letters or digits. parse_number will
1206 complain if past the radix, or if L or U are not final. */
1207 else if ((*p < '0' || *p > '9')
1208 && ((*p < 'a' || *p > 'z')
1209 && (*p < 'A' || *p > 'Z')))
1212 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1213 if (toktype == ERROR)
1215 char *err_copy = (char *) alloca (p - tokstart + 1);
1217 memcpy (err_copy, tokstart, p - tokstart);
1218 err_copy[p - tokstart] = 0;
1219 error ("Invalid number \"%s\".", err_copy);
1250 /* Build the gdb internal form of the input string in tempbuf,
1251 translating any standard C escape forms seen. Note that the
1252 buffer is null byte terminated *only* for the convenience of
1253 debugging gdb itself and printing the buffer contents when
1254 the buffer contains no embedded nulls. Gdb does not depend
1255 upon the buffer being null byte terminated, it uses the length
1256 string instead. This allows gdb to handle C strings (as well
1257 as strings in other languages) with embedded null bytes */
1259 tokptr = ++tokstart;
1263 /* Grow the static temp buffer if necessary, including allocating
1264 the first one on demand. */
1265 if (tempbufindex + 1 >= tempbufsize)
1267 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1274 /* Do nothing, loop will terminate. */
1278 c = parse_escape (&tokptr);
1283 tempbuf[tempbufindex++] = c;
1286 tempbuf[tempbufindex++] = *tokptr++;
1289 } while ((*tokptr != '"') && (*tokptr != '\0'));
1290 if (*tokptr++ != '"')
1292 error ("Unterminated string in expression.");
1294 tempbuf[tempbufindex] = '\0'; /* See note above */
1295 yylval.sval.ptr = tempbuf;
1296 yylval.sval.length = tempbufindex;
1301 if (!(c == '_' || c == '$'
1302 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1303 /* We must have come across a bad character (e.g. ';'). */
1304 error ("Invalid character '%c' in expression.", c);
1306 /* It's a name. See how long it is. */
1308 for (c = tokstart[namelen];
1309 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1310 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1312 /* Template parameter lists are part of the name.
1313 FIXME: This mishandles `print $a<4&&$a>3'. */
1317 int nesting_level = 1;
1318 while (tokstart[++i])
1320 if (tokstart[i] == '<')
1322 else if (tokstart[i] == '>')
1324 if (--nesting_level == 0)
1328 if (tokstart[i] == '>')
1334 /* do NOT uppercase internals because of registers !!! */
1335 c = tokstart[++namelen];
1338 uptokstart = uptok(tokstart,namelen);
1340 /* The token "if" terminates the expression and is NOT
1341 removed from the input stream. */
1342 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1351 /* Catch specific keywords. Should be done with a data structure. */
1355 if (DEPRECATED_STREQ (uptokstart, "OBJECT"))
1357 if (DEPRECATED_STREQ (uptokstart, "RECORD"))
1359 if (DEPRECATED_STREQ (uptokstart, "SIZEOF"))
1363 if (DEPRECATED_STREQ (uptokstart, "CLASS"))
1365 if (DEPRECATED_STREQ (uptokstart, "FALSE"))
1368 return FALSEKEYWORD;
1372 if (DEPRECATED_STREQ (uptokstart, "TRUE"))
1377 if (DEPRECATED_STREQ (uptokstart, "SELF"))
1379 /* here we search for 'this' like
1380 inserted in FPC stabs debug info */
1381 static const char this_name[] = "this";
1383 if (lookup_symbol (this_name, expression_context_block,
1384 VAR_DOMAIN, (int *) NULL,
1385 (struct symtab **) NULL))
1393 yylval.sval.ptr = tokstart;
1394 yylval.sval.length = namelen;
1396 if (*tokstart == '$')
1398 /* $ is the normal prefix for pascal hexadecimal values
1399 but this conflicts with the GDB use for debugger variables
1400 so in expression to enter hexadecimal values
1401 we still need to use C syntax with 0xff */
1402 write_dollar_variable (yylval.sval);
1406 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1407 functions or symtabs. If this is not so, then ...
1408 Use token-type TYPENAME for symbols that happen to be defined
1409 currently as names of types; NAME for other symbols.
1410 The caller is not constrained to care about the distinction. */
1412 char *tmp = copy_name (yylval.sval);
1414 int is_a_field_of_this = 0;
1419 if (search_field && current_type)
1420 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1424 sym = lookup_symbol (tmp, expression_context_block,
1426 &is_a_field_of_this,
1427 (struct symtab **) NULL);
1428 /* second chance uppercased (as Free Pascal does). */
1429 if (!sym && !is_a_field_of_this && !is_a_field)
1431 for (i = 0; i <= namelen; i++)
1433 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1434 tmp[i] -= ('a'-'A');
1436 if (search_field && current_type)
1437 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1441 sym = lookup_symbol (tmp, expression_context_block,
1443 &is_a_field_of_this,
1444 (struct symtab **) NULL);
1445 if (sym || is_a_field_of_this || is_a_field)
1446 for (i = 0; i <= namelen; i++)
1448 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1449 tokstart[i] -= ('a'-'A');
1452 /* Third chance Capitalized (as GPC does). */
1453 if (!sym && !is_a_field_of_this && !is_a_field)
1455 for (i = 0; i <= namelen; i++)
1459 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1460 tmp[i] -= ('a'-'A');
1463 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1464 tmp[i] -= ('A'-'a');
1466 if (search_field && current_type)
1467 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1471 sym = lookup_symbol (tmp, expression_context_block,
1473 &is_a_field_of_this,
1474 (struct symtab **) NULL);
1475 if (sym || is_a_field_of_this || is_a_field)
1476 for (i = 0; i <= namelen; i++)
1480 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1481 tokstart[i] -= ('a'-'A');
1484 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
1485 tokstart[i] -= ('A'-'a');
1491 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1492 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
1493 yylval.sval.ptr = tempbuf;
1494 yylval.sval.length = namelen;
1497 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1498 no psymtabs (coff, xcoff, or some future change to blow away the
1499 psymtabs once once symbols are read). */
1500 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1501 lookup_symtab (tmp))
1503 yylval.ssym.sym = sym;
1504 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1507 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1510 /* Despite the following flaw, we need to keep this code enabled.
1511 Because we can get called from check_stub_method, if we don't
1512 handle nested types then it screws many operations in any
1513 program which uses nested types. */
1514 /* In "A::x", if x is a member function of A and there happens
1515 to be a type (nested or not, since the stabs don't make that
1516 distinction) named x, then this code incorrectly thinks we
1517 are dealing with nested types rather than a member function. */
1521 struct symbol *best_sym;
1523 /* Look ahead to detect nested types. This probably should be
1524 done in the grammar, but trying seemed to introduce a lot
1525 of shift/reduce and reduce/reduce conflicts. It's possible
1526 that it could be done, though. Or perhaps a non-grammar, but
1527 less ad hoc, approach would work well. */
1529 /* Since we do not currently have any way of distinguishing
1530 a nested type from a non-nested one (the stabs don't tell
1531 us whether a type is nested), we just ignore the
1538 /* Skip whitespace. */
1539 while (*p == ' ' || *p == '\t' || *p == '\n')
1541 if (*p == ':' && p[1] == ':')
1543 /* Skip the `::'. */
1545 /* Skip whitespace. */
1546 while (*p == ' ' || *p == '\t' || *p == '\n')
1549 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1550 || (*p >= 'a' && *p <= 'z')
1551 || (*p >= 'A' && *p <= 'Z'))
1555 struct symbol *cur_sym;
1556 /* As big as the whole rest of the expression, which is
1557 at least big enough. */
1558 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1562 memcpy (tmp1, tmp, strlen (tmp));
1563 tmp1 += strlen (tmp);
1564 memcpy (tmp1, "::", 2);
1566 memcpy (tmp1, namestart, p - namestart);
1567 tmp1[p - namestart] = '\0';
1568 cur_sym = lookup_symbol (ncopy, expression_context_block,
1569 VAR_DOMAIN, (int *) NULL,
1570 (struct symtab **) NULL);
1573 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1591 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1593 yylval.tsym.type = SYMBOL_TYPE (sym);
1598 = language_lookup_primitive_type_by_name (current_language,
1599 current_gdbarch, tmp);
1600 if (yylval.tsym.type != NULL)
1603 /* Input names that aren't symbols but ARE valid hex numbers,
1604 when the input radix permits them, can be names or numbers
1605 depending on the parse. Note we support radixes > 16 here. */
1607 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1608 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1610 YYSTYPE newlval; /* Its value is ignored. */
1611 hextype = parse_number (tokstart, namelen, 0, &newlval);
1614 yylval.ssym.sym = sym;
1615 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1621 /* Any other kind of symbol */
1622 yylval.ssym.sym = sym;
1623 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1633 lexptr = prev_lexptr;
1635 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);