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 (p, len, parsed_float, putithere)
800 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
801 here, and we do kind of silly things like cast to unsigned. */
808 int base = input_radix;
811 /* Number of "L" suffixes encountered. */
814 /* We have found a "L" or "U" suffix. */
815 int found_suffix = 0;
818 struct type *signed_type;
819 struct type *unsigned_type;
823 /* It's a float since it contains a point or an exponent. */
825 int num = 0; /* number of tokens scanned by scanf */
826 char saved_char = p[len];
828 p[len] = 0; /* null-terminate the token */
829 num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c",
830 &putithere->typed_val_float.dval, &c);
831 p[len] = saved_char; /* restore the input stream */
832 if (num != 1) /* check scanf found ONLY a float ... */
834 /* See if it has `f' or `l' suffix (float or long double). */
836 c = tolower (p[len - 1]);
839 putithere->typed_val_float.type = parse_type->builtin_float;
841 putithere->typed_val_float.type = parse_type->builtin_long_double;
842 else if (isdigit (c) || c == '.')
843 putithere->typed_val_float.type = parse_type->builtin_double;
850 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
884 if (c >= 'A' && c <= 'Z')
886 if (c != 'l' && c != 'u')
888 if (c >= '0' && c <= '9')
896 if (base > 10 && c >= 'a' && c <= 'f')
900 n += i = c - 'a' + 10;
913 return ERROR; /* Char not a digit */
916 return ERROR; /* Invalid digit in this base */
918 /* Portably test for overflow (only works for nonzero values, so make
919 a second check for zero). FIXME: Can't we just make n and prevn
920 unsigned and avoid this? */
921 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
922 unsigned_p = 1; /* Try something unsigned */
924 /* Portably test for unsigned overflow.
925 FIXME: This check is wrong; for example it doesn't find overflow
926 on 0x123456789 when LONGEST is 32 bits. */
927 if (c != 'l' && c != 'u' && n != 0)
929 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
930 error ("Numeric constant too large.");
935 /* An integer constant is an int, a long, or a long long. An L
936 suffix forces it to be long; an LL suffix forces it to be long
937 long. If not forced to a larger size, it gets the first type of
938 the above that it fits in. To figure out whether it fits, we
939 shift it right and see whether anything remains. Note that we
940 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
941 operation, because many compilers will warn about such a shift
942 (which always produces a zero result). Sometimes gdbarch_int_bit
943 or gdbarch_long_bit will be that big, sometimes not. To deal with
944 the case where it is we just always shift the value more than
945 once, with fewer bits each time. */
947 un = (ULONGEST)n >> 2;
949 && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0)
951 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1);
953 /* A large decimal (not hex or octal) constant (between INT_MAX
954 and UINT_MAX) is a long or unsigned long, according to ANSI,
955 never an unsigned int, but this code treats it as unsigned
956 int. This probably should be fixed. GCC gives a warning on
959 unsigned_type = parse_type->builtin_unsigned_int;
960 signed_type = parse_type->builtin_int;
963 && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0)
965 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1);
966 unsigned_type = parse_type->builtin_unsigned_long;
967 signed_type = parse_type->builtin_long;
972 if (sizeof (ULONGEST) * HOST_CHAR_BIT
973 < gdbarch_long_long_bit (parse_gdbarch))
974 /* A long long does not fit in a LONGEST. */
975 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
977 shift = (gdbarch_long_long_bit (parse_gdbarch) - 1);
978 high_bit = (ULONGEST) 1 << shift;
979 unsigned_type = parse_type->builtin_unsigned_long_long;
980 signed_type = parse_type->builtin_long_long;
983 putithere->typed_val_int.val = n;
985 /* If the high bit of the worked out type is set then this number
986 has to be unsigned. */
988 if (unsigned_p || (n & high_bit))
990 putithere->typed_val_int.type = unsigned_type;
994 putithere->typed_val_int.type = signed_type;
1003 struct type *stored;
1004 struct type_push *next;
1007 static struct type_push *tp_top = NULL;
1010 push_current_type (void)
1012 struct type_push *tpnew;
1013 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
1014 tpnew->next = tp_top;
1015 tpnew->stored = current_type;
1016 current_type = NULL;
1021 pop_current_type (void)
1023 struct type_push *tp = tp_top;
1026 current_type = tp->stored;
1036 enum exp_opcode opcode;
1039 static const struct token tokentab3[] =
1041 {"shr", RSH, BINOP_END},
1042 {"shl", LSH, BINOP_END},
1043 {"and", ANDAND, BINOP_END},
1044 {"div", DIV, BINOP_END},
1045 {"not", NOT, BINOP_END},
1046 {"mod", MOD, BINOP_END},
1047 {"inc", INCREMENT, BINOP_END},
1048 {"dec", DECREMENT, BINOP_END},
1049 {"xor", XOR, BINOP_END}
1052 static const struct token tokentab2[] =
1054 {"or", OR, BINOP_END},
1055 {"<>", NOTEQUAL, BINOP_END},
1056 {"<=", LEQ, BINOP_END},
1057 {">=", GEQ, BINOP_END},
1058 {":=", ASSIGN, BINOP_END},
1059 {"::", COLONCOLON, BINOP_END} };
1061 /* Allocate uppercased var */
1062 /* make an uppercased copy of tokstart */
1063 static char * uptok (tokstart, namelen)
1068 char *uptokstart = (char *)malloc(namelen+1);
1069 for (i = 0;i <= namelen;i++)
1071 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1072 uptokstart[i] = tokstart[i]-('a'-'A');
1074 uptokstart[i] = tokstart[i];
1076 uptokstart[namelen]='\0';
1079 /* Read one token, getting characters through lexptr. */
1091 int explen, tempbufindex;
1092 static char *tempbuf;
1093 static int tempbufsize;
1097 prev_lexptr = lexptr;
1100 explen = strlen (lexptr);
1101 /* See if it is a special token of length 3. */
1103 for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1104 if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0
1105 && (!isalpha (tokentab3[i].operator[0]) || explen == 3
1106 || (!isalpha (tokstart[3]) && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1109 yylval.opcode = tokentab3[i].opcode;
1110 return tokentab3[i].token;
1113 /* See if it is a special token of length 2. */
1115 for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1116 if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0
1117 && (!isalpha (tokentab2[i].operator[0]) || explen == 2
1118 || (!isalpha (tokstart[2]) && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1121 yylval.opcode = tokentab2[i].opcode;
1122 return tokentab2[i].token;
1125 switch (c = *tokstart)
1137 /* We either have a character constant ('0' or '\177' for example)
1138 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1143 c = parse_escape (parse_gdbarch, &lexptr);
1145 error ("Empty character constant.");
1147 yylval.typed_val_int.val = c;
1148 yylval.typed_val_int.type = parse_type->builtin_char;
1153 namelen = skip_quoted (tokstart) - tokstart;
1156 lexptr = tokstart + namelen;
1157 if (lexptr[-1] != '\'')
1158 error ("Unmatched single quote.");
1161 uptokstart = uptok(tokstart,namelen);
1164 error ("Invalid character constant.");
1174 if (paren_depth == 0)
1181 if (comma_terminates && paren_depth == 0)
1187 /* Might be a floating point number. */
1188 if (lexptr[1] < '0' || lexptr[1] > '9')
1189 goto symbol; /* Nope, must be a symbol. */
1190 /* FALL THRU into number case. */
1203 /* It's a number. */
1204 int got_dot = 0, got_e = 0, toktype;
1206 int hex = input_radix > 10;
1208 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1213 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1221 /* This test includes !hex because 'e' is a valid hex digit
1222 and thus does not indicate a floating point number when
1223 the radix is hex. */
1224 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1225 got_dot = got_e = 1;
1226 /* This test does not include !hex, because a '.' always indicates
1227 a decimal floating point number regardless of the radix. */
1228 else if (!got_dot && *p == '.')
1230 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1231 && (*p == '-' || *p == '+'))
1232 /* This is the sign of the exponent, not the end of the
1235 /* We will take any letters or digits. parse_number will
1236 complain if past the radix, or if L or U are not final. */
1237 else if ((*p < '0' || *p > '9')
1238 && ((*p < 'a' || *p > 'z')
1239 && (*p < 'A' || *p > 'Z')))
1242 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1243 if (toktype == ERROR)
1245 char *err_copy = (char *) alloca (p - tokstart + 1);
1247 memcpy (err_copy, tokstart, p - tokstart);
1248 err_copy[p - tokstart] = 0;
1249 error ("Invalid number \"%s\".", err_copy);
1280 /* Build the gdb internal form of the input string in tempbuf,
1281 translating any standard C escape forms seen. Note that the
1282 buffer is null byte terminated *only* for the convenience of
1283 debugging gdb itself and printing the buffer contents when
1284 the buffer contains no embedded nulls. Gdb does not depend
1285 upon the buffer being null byte terminated, it uses the length
1286 string instead. This allows gdb to handle C strings (as well
1287 as strings in other languages) with embedded null bytes */
1289 tokptr = ++tokstart;
1293 /* Grow the static temp buffer if necessary, including allocating
1294 the first one on demand. */
1295 if (tempbufindex + 1 >= tempbufsize)
1297 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1304 /* Do nothing, loop will terminate. */
1308 c = parse_escape (parse_gdbarch, &tokptr);
1313 tempbuf[tempbufindex++] = c;
1316 tempbuf[tempbufindex++] = *tokptr++;
1319 } while ((*tokptr != '"') && (*tokptr != '\0'));
1320 if (*tokptr++ != '"')
1322 error ("Unterminated string in expression.");
1324 tempbuf[tempbufindex] = '\0'; /* See note above */
1325 yylval.sval.ptr = tempbuf;
1326 yylval.sval.length = tempbufindex;
1331 if (!(c == '_' || c == '$'
1332 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1333 /* We must have come across a bad character (e.g. ';'). */
1334 error ("Invalid character '%c' in expression.", c);
1336 /* It's a name. See how long it is. */
1338 for (c = tokstart[namelen];
1339 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1340 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1342 /* Template parameter lists are part of the name.
1343 FIXME: This mishandles `print $a<4&&$a>3'. */
1347 int nesting_level = 1;
1348 while (tokstart[++i])
1350 if (tokstart[i] == '<')
1352 else if (tokstart[i] == '>')
1354 if (--nesting_level == 0)
1358 if (tokstart[i] == '>')
1364 /* do NOT uppercase internals because of registers !!! */
1365 c = tokstart[++namelen];
1368 uptokstart = uptok(tokstart,namelen);
1370 /* The token "if" terminates the expression and is NOT
1371 removed from the input stream. */
1372 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1382 /* Catch specific keywords. Should be done with a data structure. */
1386 if (strcmp (uptokstart, "OBJECT") == 0)
1391 if (strcmp (uptokstart, "RECORD") == 0)
1396 if (strcmp (uptokstart, "SIZEOF") == 0)
1403 if (strcmp (uptokstart, "CLASS") == 0)
1408 if (strcmp (uptokstart, "FALSE") == 0)
1412 return FALSEKEYWORD;
1416 if (strcmp (uptokstart, "TRUE") == 0)
1422 if (strcmp (uptokstart, "SELF") == 0)
1424 /* here we search for 'this' like
1425 inserted in FPC stabs debug info */
1426 static const char this_name[] = "this";
1428 if (lookup_symbol (this_name, expression_context_block,
1429 VAR_DOMAIN, (int *) NULL))
1440 yylval.sval.ptr = tokstart;
1441 yylval.sval.length = namelen;
1443 if (*tokstart == '$')
1445 /* $ is the normal prefix for pascal hexadecimal values
1446 but this conflicts with the GDB use for debugger variables
1447 so in expression to enter hexadecimal values
1448 we still need to use C syntax with 0xff */
1449 write_dollar_variable (yylval.sval);
1454 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1455 functions or symtabs. If this is not so, then ...
1456 Use token-type TYPENAME for symbols that happen to be defined
1457 currently as names of types; NAME for other symbols.
1458 The caller is not constrained to care about the distinction. */
1460 char *tmp = copy_name (yylval.sval);
1462 int is_a_field_of_this = 0;
1467 if (search_field && current_type)
1468 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1472 sym = lookup_symbol (tmp, expression_context_block,
1473 VAR_DOMAIN, &is_a_field_of_this);
1474 /* second chance uppercased (as Free Pascal does). */
1475 if (!sym && !is_a_field_of_this && !is_a_field)
1477 for (i = 0; i <= namelen; i++)
1479 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1480 tmp[i] -= ('a'-'A');
1482 if (search_field && current_type)
1483 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1487 sym = lookup_symbol (tmp, expression_context_block,
1488 VAR_DOMAIN, &is_a_field_of_this);
1489 if (sym || is_a_field_of_this || is_a_field)
1490 for (i = 0; i <= namelen; i++)
1492 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1493 tokstart[i] -= ('a'-'A');
1496 /* Third chance Capitalized (as GPC does). */
1497 if (!sym && !is_a_field_of_this && !is_a_field)
1499 for (i = 0; i <= namelen; i++)
1503 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1504 tmp[i] -= ('a'-'A');
1507 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1508 tmp[i] -= ('A'-'a');
1510 if (search_field && current_type)
1511 is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL);
1515 sym = lookup_symbol (tmp, expression_context_block,
1516 VAR_DOMAIN, &is_a_field_of_this);
1517 if (sym || is_a_field_of_this || is_a_field)
1518 for (i = 0; i <= namelen; i++)
1522 if ((tokstart[i] >= 'a' && tokstart[i] <= 'z'))
1523 tokstart[i] -= ('a'-'A');
1526 if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z'))
1527 tokstart[i] -= ('A'-'a');
1533 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1534 strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0;
1535 yylval.sval.ptr = tempbuf;
1536 yylval.sval.length = namelen;
1540 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1541 no psymtabs (coff, xcoff, or some future change to blow away the
1542 psymtabs once once symbols are read). */
1543 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1544 || lookup_symtab (tmp))
1546 yylval.ssym.sym = sym;
1547 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1551 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1554 /* Despite the following flaw, we need to keep this code enabled.
1555 Because we can get called from check_stub_method, if we don't
1556 handle nested types then it screws many operations in any
1557 program which uses nested types. */
1558 /* In "A::x", if x is a member function of A and there happens
1559 to be a type (nested or not, since the stabs don't make that
1560 distinction) named x, then this code incorrectly thinks we
1561 are dealing with nested types rather than a member function. */
1565 struct symbol *best_sym;
1567 /* Look ahead to detect nested types. This probably should be
1568 done in the grammar, but trying seemed to introduce a lot
1569 of shift/reduce and reduce/reduce conflicts. It's possible
1570 that it could be done, though. Or perhaps a non-grammar, but
1571 less ad hoc, approach would work well. */
1573 /* Since we do not currently have any way of distinguishing
1574 a nested type from a non-nested one (the stabs don't tell
1575 us whether a type is nested), we just ignore the
1582 /* Skip whitespace. */
1583 while (*p == ' ' || *p == '\t' || *p == '\n')
1585 if (*p == ':' && p[1] == ':')
1587 /* Skip the `::'. */
1589 /* Skip whitespace. */
1590 while (*p == ' ' || *p == '\t' || *p == '\n')
1593 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1594 || (*p >= 'a' && *p <= 'z')
1595 || (*p >= 'A' && *p <= 'Z'))
1599 struct symbol *cur_sym;
1600 /* As big as the whole rest of the expression, which is
1601 at least big enough. */
1602 char *ncopy = alloca (strlen (tmp)+strlen (namestart)+3);
1606 memcpy (tmp1, tmp, strlen (tmp));
1607 tmp1 += strlen (tmp);
1608 memcpy (tmp1, "::", 2);
1610 memcpy (tmp1, namestart, p - namestart);
1611 tmp1[p - namestart] = '\0';
1612 cur_sym = lookup_symbol (ncopy, expression_context_block,
1613 VAR_DOMAIN, (int *) NULL);
1616 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1634 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1636 yylval.tsym.type = SYMBOL_TYPE (sym);
1642 = language_lookup_primitive_type_by_name (parse_language,
1643 parse_gdbarch, tmp);
1644 if (yylval.tsym.type != NULL)
1650 /* Input names that aren't symbols but ARE valid hex numbers,
1651 when the input radix permits them, can be names or numbers
1652 depending on the parse. Note we support radixes > 16 here. */
1654 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1655 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1657 YYSTYPE newlval; /* Its value is ignored. */
1658 hextype = parse_number (tokstart, namelen, 0, &newlval);
1661 yylval.ssym.sym = sym;
1662 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1669 /* Any other kind of symbol */
1670 yylval.ssym.sym = sym;
1671 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1681 lexptr = prev_lexptr;
1683 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);