1 /* YACC parser for Pascal expressions, for GDB.
2 Copyright (C) 2000-2020 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 3 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, see <http://www.gnu.org/licenses/>. */
19 /* This file is derived from c-exp.y */
21 /* Parse a Pascal expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
38 /* Known bugs or limitations:
39 - pascal string operations are not supported at all.
40 - there are some problems with boolean types.
41 - Pascal type hexadecimal constants are not supported
42 because they conflict with the internal variables format.
43 Probably also lots of other problems, less well defined PM. */
48 #include "expression.h"
50 #include "parser-defs.h"
53 #include "bfd.h" /* Required by objfiles.h. */
54 #include "symfile.h" /* Required by objfiles.h. */
55 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */
57 #include "completer.h"
59 #define parse_type(ps) builtin_type (ps->gdbarch ())
61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
63 #define GDB_YY_REMAP_PREFIX pascal_
66 /* The state of the parser, used internally when we are parsing the
69 static struct parser_state *pstate = NULL;
71 /* Depth of parentheses. */
72 static int paren_depth;
76 static int yylex (void);
78 static void yyerror (const char *);
80 static char *uptok (const char *, int);
83 /* Although the yacc "value" of an expression is not used,
84 since the result is stored in the structure being created,
85 other node types do have values. */
102 struct symtoken ssym;
104 const struct block *bval;
105 enum exp_opcode opcode;
106 struct internalvar *ivar;
113 /* YYSTYPE gets defined by %union */
114 static int parse_number (struct parser_state *,
115 const char *, int, int, YYSTYPE *);
117 static struct type *current_type;
118 static int leftdiv_is_integer;
119 static void push_current_type (void);
120 static void pop_current_type (void);
121 static int search_field;
124 %type <voidval> exp exp1 type_exp start normal_start variable qualified_name
125 %type <tval> type typebase
126 /* %type <bval> block */
128 /* Fancy type parsing. */
131 %token <typed_val_int> INT
132 %token <typed_val_float> FLOAT
134 /* Both NAME and TYPENAME tokens represent symbols in the input,
135 and both convey their data as strings.
136 But a TYPENAME is a string that happens to be defined as a typedef
137 or builtin type name (such as int or char)
138 and a NAME is any other symbol.
139 Contexts where this distinction is not important can use the
140 nonterminal "name", which matches either NAME or TYPENAME. */
143 %token <sval> FIELDNAME
144 %token <voidval> COMPLETE
145 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
146 %token <tsym> TYPENAME
148 %type <ssym> name_not_typename
150 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
151 but which would parse as a valid number in the current input radix.
152 E.g. "c" when input_radix==16. Depending on the parse, it will be
153 turned into a name or into a number. */
155 %token <ssym> NAME_OR_INT
157 %token STRUCT CLASS SIZEOF COLONCOLON
160 /* Special type cases, put in to allow the parser to distinguish different
163 %token <sval> DOLLAR_VARIABLE
168 %token <lval> TRUEKEYWORD FALSEKEYWORD
178 %left '<' '>' LEQ GEQ
179 %left LSH RSH DIV MOD
183 %right UNARY INCREMENT DECREMENT
184 %right ARROW '.' '[' '('
186 %token <ssym> BLOCKNAME
193 start : { current_type = NULL;
195 leftdiv_is_integer = 0;
206 { write_exp_elt_opcode (pstate, OP_TYPE);
207 write_exp_elt_type (pstate, $1);
208 write_exp_elt_opcode (pstate, OP_TYPE);
209 current_type = $1; } ;
211 /* Expressions, including the comma operator. */
214 { write_exp_elt_opcode (pstate, BINOP_COMMA); }
217 /* Expressions, not including the comma operator. */
218 exp : exp '^' %prec UNARY
219 { write_exp_elt_opcode (pstate, UNOP_IND);
221 current_type = TYPE_TARGET_TYPE (current_type); }
224 exp : '@' exp %prec UNARY
225 { write_exp_elt_opcode (pstate, UNOP_ADDR);
227 current_type = TYPE_POINTER_TYPE (current_type); }
230 exp : '-' exp %prec UNARY
231 { write_exp_elt_opcode (pstate, UNOP_NEG); }
234 exp : NOT exp %prec UNARY
235 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
238 exp : INCREMENT '(' exp ')' %prec UNARY
239 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
242 exp : DECREMENT '(' exp ')' %prec UNARY
243 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
247 field_exp : exp '.' %prec UNARY
248 { search_field = 1; }
251 exp : field_exp FIELDNAME
252 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
253 write_exp_string (pstate, $2);
254 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
258 while (current_type->code ()
261 TYPE_TARGET_TYPE (current_type);
262 current_type = lookup_struct_elt_type (
263 current_type, $2.ptr, 0);
270 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
271 write_exp_string (pstate, $2);
272 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
276 while (current_type->code ()
279 TYPE_TARGET_TYPE (current_type);
280 current_type = lookup_struct_elt_type (
281 current_type, $2.ptr, 0);
285 exp : field_exp name COMPLETE
286 { pstate->mark_struct_expression ();
287 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
288 write_exp_string (pstate, $2);
289 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
291 exp : field_exp COMPLETE
293 pstate->mark_struct_expression ();
294 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
297 write_exp_string (pstate, s);
298 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
302 /* We need to save the current_type value. */
303 { const char *arrayname;
305 = pascal_is_string_type (current_type, NULL, NULL,
306 NULL, NULL, &arrayname);
309 struct stoken stringsval;
312 buf = (char *) alloca (strlen (arrayname) + 1);
313 stringsval.ptr = buf;
314 stringsval.length = strlen (arrayname);
315 strcpy (buf, arrayname);
318 ->field (arrayfieldindex - 1).type ());
319 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
320 write_exp_string (pstate, stringsval);
321 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
323 push_current_type (); }
325 { pop_current_type ();
326 write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
328 current_type = TYPE_TARGET_TYPE (current_type); }
332 /* This is to save the value of arglist_len
333 being accumulated by an outer function call. */
334 { push_current_type ();
335 pstate->start_arglist (); }
336 arglist ')' %prec ARROW
337 { write_exp_elt_opcode (pstate, OP_FUNCALL);
338 write_exp_elt_longcst (pstate,
339 pstate->end_arglist ());
340 write_exp_elt_opcode (pstate, OP_FUNCALL);
343 current_type = TYPE_TARGET_TYPE (current_type);
349 { pstate->arglist_len = 1; }
350 | arglist ',' exp %prec ABOVE_COMMA
351 { pstate->arglist_len++; }
354 exp : type '(' exp ')' %prec UNARY
357 /* Allow automatic dereference of classes. */
358 if ((current_type->code () == TYPE_CODE_PTR)
359 && (TYPE_TARGET_TYPE (current_type)->code () == TYPE_CODE_STRUCT)
360 && (($1)->code () == TYPE_CODE_STRUCT))
361 write_exp_elt_opcode (pstate, UNOP_IND);
363 write_exp_elt_opcode (pstate, UNOP_CAST);
364 write_exp_elt_type (pstate, $1);
365 write_exp_elt_opcode (pstate, UNOP_CAST);
373 /* Binary operators in order of decreasing precedence. */
376 { write_exp_elt_opcode (pstate, BINOP_MUL); }
380 if (current_type && is_integral_type (current_type))
381 leftdiv_is_integer = 1;
385 if (leftdiv_is_integer && current_type
386 && is_integral_type (current_type))
388 write_exp_elt_opcode (pstate, UNOP_CAST);
389 write_exp_elt_type (pstate,
391 ->builtin_long_double);
393 = parse_type (pstate)->builtin_long_double;
394 write_exp_elt_opcode (pstate, UNOP_CAST);
395 leftdiv_is_integer = 0;
398 write_exp_elt_opcode (pstate, BINOP_DIV);
403 { write_exp_elt_opcode (pstate, BINOP_INTDIV); }
407 { write_exp_elt_opcode (pstate, BINOP_REM); }
411 { write_exp_elt_opcode (pstate, BINOP_ADD); }
415 { write_exp_elt_opcode (pstate, BINOP_SUB); }
419 { write_exp_elt_opcode (pstate, BINOP_LSH); }
423 { write_exp_elt_opcode (pstate, BINOP_RSH); }
427 { write_exp_elt_opcode (pstate, BINOP_EQUAL);
428 current_type = parse_type (pstate)->builtin_bool;
432 exp : exp NOTEQUAL exp
433 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL);
434 current_type = parse_type (pstate)->builtin_bool;
439 { write_exp_elt_opcode (pstate, BINOP_LEQ);
440 current_type = parse_type (pstate)->builtin_bool;
445 { write_exp_elt_opcode (pstate, BINOP_GEQ);
446 current_type = parse_type (pstate)->builtin_bool;
451 { write_exp_elt_opcode (pstate, BINOP_LESS);
452 current_type = parse_type (pstate)->builtin_bool;
457 { write_exp_elt_opcode (pstate, BINOP_GTR);
458 current_type = parse_type (pstate)->builtin_bool;
463 { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
467 { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
471 { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
475 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
479 { write_exp_elt_opcode (pstate, OP_BOOL);
480 write_exp_elt_longcst (pstate, (LONGEST) $1);
481 current_type = parse_type (pstate)->builtin_bool;
482 write_exp_elt_opcode (pstate, OP_BOOL); }
486 { write_exp_elt_opcode (pstate, OP_BOOL);
487 write_exp_elt_longcst (pstate, (LONGEST) $1);
488 current_type = parse_type (pstate)->builtin_bool;
489 write_exp_elt_opcode (pstate, OP_BOOL); }
493 { write_exp_elt_opcode (pstate, OP_LONG);
494 write_exp_elt_type (pstate, $1.type);
495 current_type = $1.type;
496 write_exp_elt_longcst (pstate, (LONGEST)($1.val));
497 write_exp_elt_opcode (pstate, OP_LONG); }
502 parse_number (pstate, $1.stoken.ptr,
503 $1.stoken.length, 0, &val);
504 write_exp_elt_opcode (pstate, OP_LONG);
505 write_exp_elt_type (pstate, val.typed_val_int.type);
506 current_type = val.typed_val_int.type;
507 write_exp_elt_longcst (pstate, (LONGEST)
508 val.typed_val_int.val);
509 write_exp_elt_opcode (pstate, OP_LONG);
515 { write_exp_elt_opcode (pstate, OP_FLOAT);
516 write_exp_elt_type (pstate, $1.type);
517 current_type = $1.type;
518 write_exp_elt_floatcst (pstate, $1.val);
519 write_exp_elt_opcode (pstate, OP_FLOAT); }
525 exp : DOLLAR_VARIABLE
527 write_dollar_variable (pstate, $1);
529 /* $ is the normal prefix for pascal
530 hexadecimal values but this conflicts
531 with the GDB use for debugger variables
532 so in expression to enter hexadecimal
533 values we still need to use C syntax with
535 std::string tmp ($1.ptr, $1.length);
536 /* Handle current_type. */
537 struct internalvar *intvar
538 = lookup_only_internalvar (tmp.c_str () + 1);
539 if (intvar != nullptr)
541 scoped_value_mark mark;
544 = value_of_internalvar (pstate->gdbarch (),
546 current_type = value_type (val);
551 exp : SIZEOF '(' type ')' %prec UNARY
552 { write_exp_elt_opcode (pstate, OP_LONG);
553 write_exp_elt_type (pstate,
554 parse_type (pstate)->builtin_int);
555 current_type = parse_type (pstate)->builtin_int;
556 $3 = check_typedef ($3);
557 write_exp_elt_longcst (pstate,
558 (LONGEST) TYPE_LENGTH ($3));
559 write_exp_elt_opcode (pstate, OP_LONG); }
562 exp : SIZEOF '(' exp ')' %prec UNARY
563 { write_exp_elt_opcode (pstate, UNOP_SIZEOF);
564 current_type = parse_type (pstate)->builtin_int; }
567 { /* C strings are converted into array constants with
568 an explicit null byte added at the end. Thus
569 the array upper bound is the string length.
570 There is no such thing in C as a completely empty
572 const char *sp = $1.ptr; int count = $1.length;
576 write_exp_elt_opcode (pstate, OP_LONG);
577 write_exp_elt_type (pstate,
580 write_exp_elt_longcst (pstate,
582 write_exp_elt_opcode (pstate, OP_LONG);
584 write_exp_elt_opcode (pstate, OP_LONG);
585 write_exp_elt_type (pstate,
588 write_exp_elt_longcst (pstate, (LONGEST)'\0');
589 write_exp_elt_opcode (pstate, OP_LONG);
590 write_exp_elt_opcode (pstate, OP_ARRAY);
591 write_exp_elt_longcst (pstate, (LONGEST) 0);
592 write_exp_elt_longcst (pstate,
593 (LONGEST) ($1.length));
594 write_exp_elt_opcode (pstate, OP_ARRAY); }
600 struct value * this_val;
601 struct type * this_type;
602 write_exp_elt_opcode (pstate, OP_THIS);
603 write_exp_elt_opcode (pstate, OP_THIS);
604 /* We need type of this. */
606 = value_of_this_silent (pstate->language ());
608 this_type = value_type (this_val);
613 if (this_type->code () == TYPE_CODE_PTR)
615 this_type = TYPE_TARGET_TYPE (this_type);
616 write_exp_elt_opcode (pstate, UNOP_IND);
620 current_type = this_type;
624 /* end of object pascal. */
628 if ($1.sym.symbol != 0)
629 $$ = SYMBOL_BLOCK_VALUE ($1.sym.symbol);
632 std::string copy = copy_name ($1.stoken);
634 lookup_symtab (copy.c_str ());
636 $$ = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (tem),
639 error (_("No file or function \"%s\"."),
645 block : block COLONCOLON name
647 std::string copy = copy_name ($3);
649 = lookup_symbol (copy.c_str (), $1,
650 VAR_DOMAIN, NULL).symbol;
652 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
653 error (_("No function \"%s\" in specified context."),
655 $$ = SYMBOL_BLOCK_VALUE (tem); }
658 variable: block COLONCOLON name
659 { struct block_symbol sym;
661 std::string copy = copy_name ($3);
662 sym = lookup_symbol (copy.c_str (), $1,
665 error (_("No symbol \"%s\" in specified context."),
668 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
669 write_exp_elt_block (pstate, sym.block);
670 write_exp_elt_sym (pstate, sym.symbol);
671 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
674 qualified_name: typebase COLONCOLON name
676 struct type *type = $1;
678 if (type->code () != TYPE_CODE_STRUCT
679 && type->code () != TYPE_CODE_UNION)
680 error (_("`%s' is not defined as an aggregate type."),
683 write_exp_elt_opcode (pstate, OP_SCOPE);
684 write_exp_elt_type (pstate, type);
685 write_exp_string (pstate, $3);
686 write_exp_elt_opcode (pstate, OP_SCOPE);
690 variable: qualified_name
693 std::string name = copy_name ($2);
695 struct bound_minimal_symbol msymbol;
698 lookup_symbol (name.c_str (),
699 (const struct block *) NULL,
700 VAR_DOMAIN, NULL).symbol;
703 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
704 write_exp_elt_block (pstate, NULL);
705 write_exp_elt_sym (pstate, sym);
706 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
711 = lookup_bound_minimal_symbol (name.c_str ());
712 if (msymbol.minsym != NULL)
713 write_exp_msymbol (pstate, msymbol);
714 else if (!have_full_symbols ()
715 && !have_partial_symbols ())
716 error (_("No symbol table is loaded. "
717 "Use the \"file\" command."));
719 error (_("No symbol \"%s\" in current context."),
724 variable: name_not_typename
725 { struct block_symbol sym = $1.sym;
729 if (symbol_read_needs_frame (sym.symbol))
730 pstate->block_tracker->update (sym);
732 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
733 write_exp_elt_block (pstate, sym.block);
734 write_exp_elt_sym (pstate, sym.symbol);
735 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
736 current_type = sym.symbol->type; }
737 else if ($1.is_a_field_of_this)
739 struct value * this_val;
740 struct type * this_type;
741 /* Object pascal: it hangs off of `this'. Must
742 not inadvertently convert from a method call
744 pstate->block_tracker->update (sym);
745 write_exp_elt_opcode (pstate, OP_THIS);
746 write_exp_elt_opcode (pstate, OP_THIS);
747 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
748 write_exp_string (pstate, $1.stoken);
749 write_exp_elt_opcode (pstate, STRUCTOP_PTR);
750 /* We need type of this. */
752 = value_of_this_silent (pstate->language ());
754 this_type = value_type (this_val);
758 current_type = lookup_struct_elt_type (
760 copy_name ($1.stoken).c_str (), 0);
766 struct bound_minimal_symbol msymbol;
767 std::string arg = copy_name ($1.stoken);
770 lookup_bound_minimal_symbol (arg.c_str ());
771 if (msymbol.minsym != NULL)
772 write_exp_msymbol (pstate, msymbol);
773 else if (!have_full_symbols ()
774 && !have_partial_symbols ())
775 error (_("No symbol table is loaded. "
776 "Use the \"file\" command."));
778 error (_("No symbol \"%s\" in current context."),
788 /* We used to try to recognize more pointer to member types here, but
789 that didn't work (shift/reduce conflicts meant that these rules never
790 got executed). The problem is that
791 int (foo::bar::baz::bizzle)
792 is a function type but
793 int (foo::bar::baz::bizzle::*)
794 is a pointer to member type. Stroustrup loses again! */
799 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
801 { $$ = lookup_pointer_type ($2); }
806 = lookup_struct (copy_name ($2).c_str (),
807 pstate->expression_context_block);
811 = lookup_struct (copy_name ($2).c_str (),
812 pstate->expression_context_block);
814 /* "const" and "volatile" are curently ignored. A type qualifier
815 after the type is handled in the ptype rule. I think these could
819 name : NAME { $$ = $1.stoken; }
820 | BLOCKNAME { $$ = $1.stoken; }
821 | TYPENAME { $$ = $1.stoken; }
822 | NAME_OR_INT { $$ = $1.stoken; }
825 name_not_typename : NAME
827 /* These would be useful if name_not_typename was useful, but it is just
828 a fake for "variable", so these cause reduce/reduce conflicts because
829 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
830 =exp) or just an exp. If name_not_typename was ever used in an lvalue
831 context where only a name could occur, this might be useful.
838 /* Take care of parsing a number (anything that starts with a digit).
839 Set yylval and return the token type; update lexptr.
840 LEN is the number of characters in it. */
842 /*** Needs some error checking for the float case ***/
845 parse_number (struct parser_state *par_state,
846 const char *p, int len, int parsed_float, YYSTYPE *putithere)
848 /* FIXME: Shouldn't these be unsigned? We don't deal with negative values
849 here, and we do kind of silly things like cast to unsigned. */
856 int base = input_radix;
859 /* Number of "L" suffixes encountered. */
862 /* We have found a "L" or "U" suffix. */
863 int found_suffix = 0;
866 struct type *signed_type;
867 struct type *unsigned_type;
871 /* Handle suffixes: 'f' for float, 'l' for long double.
872 FIXME: This appears to be an extension -- do we want this? */
873 if (len >= 1 && tolower (p[len - 1]) == 'f')
875 putithere->typed_val_float.type
876 = parse_type (par_state)->builtin_float;
879 else if (len >= 1 && tolower (p[len - 1]) == 'l')
881 putithere->typed_val_float.type
882 = parse_type (par_state)->builtin_long_double;
885 /* Default type for floating-point literals is double. */
888 putithere->typed_val_float.type
889 = parse_type (par_state)->builtin_double;
892 if (!parse_float (p, len,
893 putithere->typed_val_float.type,
894 putithere->typed_val_float.val))
899 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
933 if (c >= 'A' && c <= 'Z')
935 if (c != 'l' && c != 'u')
937 if (c >= '0' && c <= '9')
945 if (base > 10 && c >= 'a' && c <= 'f')
949 n += i = c - 'a' + 10;
962 return ERROR; /* Char not a digit */
965 return ERROR; /* Invalid digit in this base. */
967 /* Portably test for overflow (only works for nonzero values, so make
968 a second check for zero). FIXME: Can't we just make n and prevn
969 unsigned and avoid this? */
970 if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
971 unsigned_p = 1; /* Try something unsigned. */
973 /* Portably test for unsigned overflow.
974 FIXME: This check is wrong; for example it doesn't find overflow
975 on 0x123456789 when LONGEST is 32 bits. */
976 if (c != 'l' && c != 'u' && n != 0)
978 if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
979 error (_("Numeric constant too large."));
984 /* An integer constant is an int, a long, or a long long. An L
985 suffix forces it to be long; an LL suffix forces it to be long
986 long. If not forced to a larger size, it gets the first type of
987 the above that it fits in. To figure out whether it fits, we
988 shift it right and see whether anything remains. Note that we
989 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
990 operation, because many compilers will warn about such a shift
991 (which always produces a zero result). Sometimes gdbarch_int_bit
992 or gdbarch_long_bit will be that big, sometimes not. To deal with
993 the case where it is we just always shift the value more than
994 once, with fewer bits each time. */
996 un = (ULONGEST)n >> 2;
998 && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
1001 = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
1003 /* A large decimal (not hex or octal) constant (between INT_MAX
1004 and UINT_MAX) is a long or unsigned long, according to ANSI,
1005 never an unsigned int, but this code treats it as unsigned
1006 int. This probably should be fixed. GCC gives a warning on
1009 unsigned_type = parse_type (par_state)->builtin_unsigned_int;
1010 signed_type = parse_type (par_state)->builtin_int;
1012 else if (long_p <= 1
1013 && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
1016 = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
1017 unsigned_type = parse_type (par_state)->builtin_unsigned_long;
1018 signed_type = parse_type (par_state)->builtin_long;
1023 if (sizeof (ULONGEST) * HOST_CHAR_BIT
1024 < gdbarch_long_long_bit (par_state->gdbarch ()))
1025 /* A long long does not fit in a LONGEST. */
1026 shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1028 shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
1029 high_bit = (ULONGEST) 1 << shift;
1030 unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
1031 signed_type = parse_type (par_state)->builtin_long_long;
1034 putithere->typed_val_int.val = n;
1036 /* If the high bit of the worked out type is set then this number
1037 has to be unsigned. */
1039 if (unsigned_p || (n & high_bit))
1041 putithere->typed_val_int.type = unsigned_type;
1045 putithere->typed_val_int.type = signed_type;
1054 struct type *stored;
1055 struct type_push *next;
1058 static struct type_push *tp_top = NULL;
1061 push_current_type (void)
1063 struct type_push *tpnew;
1064 tpnew = (struct type_push *) malloc (sizeof (struct type_push));
1065 tpnew->next = tp_top;
1066 tpnew->stored = current_type;
1067 current_type = NULL;
1072 pop_current_type (void)
1074 struct type_push *tp = tp_top;
1077 current_type = tp->stored;
1087 enum exp_opcode opcode;
1090 static const struct token tokentab3[] =
1092 {"shr", RSH, BINOP_END},
1093 {"shl", LSH, BINOP_END},
1094 {"and", ANDAND, BINOP_END},
1095 {"div", DIV, BINOP_END},
1096 {"not", NOT, BINOP_END},
1097 {"mod", MOD, BINOP_END},
1098 {"inc", INCREMENT, BINOP_END},
1099 {"dec", DECREMENT, BINOP_END},
1100 {"xor", XOR, BINOP_END}
1103 static const struct token tokentab2[] =
1105 {"or", OR, BINOP_END},
1106 {"<>", NOTEQUAL, BINOP_END},
1107 {"<=", LEQ, BINOP_END},
1108 {">=", GEQ, BINOP_END},
1109 {":=", ASSIGN, BINOP_END},
1110 {"::", COLONCOLON, BINOP_END} };
1112 /* Allocate uppercased var: */
1113 /* make an uppercased copy of tokstart. */
1115 uptok (const char *tokstart, int namelen)
1118 char *uptokstart = (char *)malloc(namelen+1);
1119 for (i = 0;i <= namelen;i++)
1121 if ((tokstart[i]>='a' && tokstart[i]<='z'))
1122 uptokstart[i] = tokstart[i]-('a'-'A');
1124 uptokstart[i] = tokstart[i];
1126 uptokstart[namelen]='\0';
1130 /* Read one token, getting characters through lexptr. */
1137 const char *tokstart;
1140 int explen, tempbufindex;
1141 static char *tempbuf;
1142 static int tempbufsize;
1146 pstate->prev_lexptr = pstate->lexptr;
1148 tokstart = pstate->lexptr;
1149 explen = strlen (pstate->lexptr);
1151 /* See if it is a special token of length 3. */
1153 for (int i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
1154 if (strncasecmp (tokstart, tokentab3[i].oper, 3) == 0
1155 && (!isalpha (tokentab3[i].oper[0]) || explen == 3
1156 || (!isalpha (tokstart[3])
1157 && !isdigit (tokstart[3]) && tokstart[3] != '_')))
1159 pstate->lexptr += 3;
1160 yylval.opcode = tokentab3[i].opcode;
1161 return tokentab3[i].token;
1164 /* See if it is a special token of length 2. */
1166 for (int i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
1167 if (strncasecmp (tokstart, tokentab2[i].oper, 2) == 0
1168 && (!isalpha (tokentab2[i].oper[0]) || explen == 2
1169 || (!isalpha (tokstart[2])
1170 && !isdigit (tokstart[2]) && tokstart[2] != '_')))
1172 pstate->lexptr += 2;
1173 yylval.opcode = tokentab2[i].opcode;
1174 return tokentab2[i].token;
1177 switch (c = *tokstart)
1180 if (search_field && pstate->parse_completion)
1192 /* We either have a character constant ('0' or '\177' for example)
1193 or we have a quoted symbol reference ('foo(int,int)' in object pascal
1196 c = *pstate->lexptr++;
1198 c = parse_escape (pstate->gdbarch (), &pstate->lexptr);
1200 error (_("Empty character constant."));
1202 yylval.typed_val_int.val = c;
1203 yylval.typed_val_int.type = parse_type (pstate)->builtin_char;
1205 c = *pstate->lexptr++;
1208 namelen = skip_quoted (tokstart) - tokstart;
1211 pstate->lexptr = tokstart + namelen;
1212 if (pstate->lexptr[-1] != '\'')
1213 error (_("Unmatched single quote."));
1216 uptokstart = uptok(tokstart,namelen);
1219 error (_("Invalid character constant."));
1229 if (paren_depth == 0)
1236 if (pstate->comma_terminates && paren_depth == 0)
1242 /* Might be a floating point number. */
1243 if (pstate->lexptr[1] < '0' || pstate->lexptr[1] > '9')
1245 goto symbol; /* Nope, must be a symbol. */
1261 /* It's a number. */
1262 int got_dot = 0, got_e = 0, toktype;
1263 const char *p = tokstart;
1264 int hex = input_radix > 10;
1266 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1271 else if (c == '0' && (p[1]=='t' || p[1]=='T'
1272 || p[1]=='d' || p[1]=='D'))
1280 /* This test includes !hex because 'e' is a valid hex digit
1281 and thus does not indicate a floating point number when
1282 the radix is hex. */
1283 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1284 got_dot = got_e = 1;
1285 /* This test does not include !hex, because a '.' always indicates
1286 a decimal floating point number regardless of the radix. */
1287 else if (!got_dot && *p == '.')
1289 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1290 && (*p == '-' || *p == '+'))
1291 /* This is the sign of the exponent, not the end of the
1294 /* We will take any letters or digits. parse_number will
1295 complain if past the radix, or if L or U are not final. */
1296 else if ((*p < '0' || *p > '9')
1297 && ((*p < 'a' || *p > 'z')
1298 && (*p < 'A' || *p > 'Z')))
1301 toktype = parse_number (pstate, tokstart,
1302 p - tokstart, got_dot | got_e, &yylval);
1303 if (toktype == ERROR)
1305 char *err_copy = (char *) alloca (p - tokstart + 1);
1307 memcpy (err_copy, tokstart, p - tokstart);
1308 err_copy[p - tokstart] = 0;
1309 error (_("Invalid number \"%s\"."), err_copy);
1340 /* Build the gdb internal form of the input string in tempbuf,
1341 translating any standard C escape forms seen. Note that the
1342 buffer is null byte terminated *only* for the convenience of
1343 debugging gdb itself and printing the buffer contents when
1344 the buffer contains no embedded nulls. Gdb does not depend
1345 upon the buffer being null byte terminated, it uses the length
1346 string instead. This allows gdb to handle C strings (as well
1347 as strings in other languages) with embedded null bytes. */
1349 tokptr = ++tokstart;
1353 /* Grow the static temp buffer if necessary, including allocating
1354 the first one on demand. */
1355 if (tempbufindex + 1 >= tempbufsize)
1357 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1364 /* Do nothing, loop will terminate. */
1368 c = parse_escape (pstate->gdbarch (), &tokptr);
1373 tempbuf[tempbufindex++] = c;
1376 tempbuf[tempbufindex++] = *tokptr++;
1379 } while ((*tokptr != '"') && (*tokptr != '\0'));
1380 if (*tokptr++ != '"')
1382 error (_("Unterminated string in expression."));
1384 tempbuf[tempbufindex] = '\0'; /* See note above. */
1385 yylval.sval.ptr = tempbuf;
1386 yylval.sval.length = tempbufindex;
1387 pstate->lexptr = tokptr;
1391 if (!(c == '_' || c == '$'
1392 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1393 /* We must have come across a bad character (e.g. ';'). */
1394 error (_("Invalid character '%c' in expression."), c);
1396 /* It's a name. See how long it is. */
1398 for (c = tokstart[namelen];
1399 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1400 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1402 /* Template parameter lists are part of the name.
1403 FIXME: This mishandles `print $a<4&&$a>3'. */
1407 int nesting_level = 1;
1408 while (tokstart[++i])
1410 if (tokstart[i] == '<')
1412 else if (tokstart[i] == '>')
1414 if (--nesting_level == 0)
1418 if (tokstart[i] == '>')
1424 /* do NOT uppercase internals because of registers !!! */
1425 c = tokstart[++namelen];
1428 uptokstart = uptok(tokstart,namelen);
1430 /* The token "if" terminates the expression and is NOT
1431 removed from the input stream. */
1432 if (namelen == 2 && uptokstart[0] == 'I' && uptokstart[1] == 'F')
1438 pstate->lexptr += namelen;
1442 /* Catch specific keywords. Should be done with a data structure. */
1446 if (strcmp (uptokstart, "OBJECT") == 0)
1451 if (strcmp (uptokstart, "RECORD") == 0)
1456 if (strcmp (uptokstart, "SIZEOF") == 0)
1463 if (strcmp (uptokstart, "CLASS") == 0)
1468 if (strcmp (uptokstart, "FALSE") == 0)
1472 return FALSEKEYWORD;
1476 if (strcmp (uptokstart, "TRUE") == 0)
1482 if (strcmp (uptokstart, "SELF") == 0)
1484 /* Here we search for 'this' like
1485 inserted in FPC stabs debug info. */
1486 static const char this_name[] = "this";
1488 if (lookup_symbol (this_name, pstate->expression_context_block,
1489 VAR_DOMAIN, NULL).symbol)
1500 yylval.sval.ptr = tokstart;
1501 yylval.sval.length = namelen;
1503 if (*tokstart == '$')
1506 return DOLLAR_VARIABLE;
1509 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1510 functions or symtabs. If this is not so, then ...
1511 Use token-type TYPENAME for symbols that happen to be defined
1512 currently as names of types; NAME for other symbols.
1513 The caller is not constrained to care about the distinction. */
1515 std::string tmp = copy_name (yylval.sval);
1517 struct field_of_this_result is_a_field_of_this;
1521 is_a_field_of_this.type = NULL;
1522 if (search_field && current_type)
1523 is_a_field = (lookup_struct_elt_type (current_type,
1524 tmp.c_str (), 1) != NULL);
1528 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
1529 VAR_DOMAIN, &is_a_field_of_this).symbol;
1530 /* second chance uppercased (as Free Pascal does). */
1531 if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
1533 for (int i = 0; i <= namelen; i++)
1535 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1536 tmp[i] -= ('a'-'A');
1538 if (search_field && current_type)
1539 is_a_field = (lookup_struct_elt_type (current_type,
1540 tmp.c_str (), 1) != NULL);
1544 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
1545 VAR_DOMAIN, &is_a_field_of_this).symbol;
1547 /* Third chance Capitalized (as GPC does). */
1548 if (!sym && is_a_field_of_this.type == NULL && !is_a_field)
1550 for (int i = 0; i <= namelen; i++)
1554 if ((tmp[i] >= 'a' && tmp[i] <= 'z'))
1555 tmp[i] -= ('a'-'A');
1558 if ((tmp[i] >= 'A' && tmp[i] <= 'Z'))
1559 tmp[i] -= ('A'-'a');
1561 if (search_field && current_type)
1562 is_a_field = (lookup_struct_elt_type (current_type,
1563 tmp.c_str (), 1) != NULL);
1567 sym = lookup_symbol (tmp.c_str (), pstate->expression_context_block,
1568 VAR_DOMAIN, &is_a_field_of_this).symbol;
1571 if (is_a_field || (is_a_field_of_this.type != NULL))
1573 tempbuf = (char *) realloc (tempbuf, namelen + 1);
1574 strncpy (tempbuf, tmp.c_str (), namelen);
1575 tempbuf [namelen] = 0;
1576 yylval.sval.ptr = tempbuf;
1577 yylval.sval.length = namelen;
1578 yylval.ssym.sym.symbol = NULL;
1579 yylval.ssym.sym.block = NULL;
1581 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1587 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1588 no psymtabs (coff, xcoff, or some future change to blow away the
1589 psymtabs once once symbols are read). */
1590 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1591 || lookup_symtab (tmp.c_str ()))
1593 yylval.ssym.sym.symbol = sym;
1594 yylval.ssym.sym.block = NULL;
1595 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1599 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1602 /* Despite the following flaw, we need to keep this code enabled.
1603 Because we can get called from check_stub_method, if we don't
1604 handle nested types then it screws many operations in any
1605 program which uses nested types. */
1606 /* In "A::x", if x is a member function of A and there happens
1607 to be a type (nested or not, since the stabs don't make that
1608 distinction) named x, then this code incorrectly thinks we
1609 are dealing with nested types rather than a member function. */
1612 const char *namestart;
1613 struct symbol *best_sym;
1615 /* Look ahead to detect nested types. This probably should be
1616 done in the grammar, but trying seemed to introduce a lot
1617 of shift/reduce and reduce/reduce conflicts. It's possible
1618 that it could be done, though. Or perhaps a non-grammar, but
1619 less ad hoc, approach would work well. */
1621 /* Since we do not currently have any way of distinguishing
1622 a nested type from a non-nested one (the stabs don't tell
1623 us whether a type is nested), we just ignore the
1630 /* Skip whitespace. */
1631 while (*p == ' ' || *p == '\t' || *p == '\n')
1633 if (*p == ':' && p[1] == ':')
1635 /* Skip the `::'. */
1637 /* Skip whitespace. */
1638 while (*p == ' ' || *p == '\t' || *p == '\n')
1641 while (*p == '_' || *p == '$' || (*p >= '0' && *p <= '9')
1642 || (*p >= 'a' && *p <= 'z')
1643 || (*p >= 'A' && *p <= 'Z'))
1647 struct symbol *cur_sym;
1648 /* As big as the whole rest of the expression, which is
1649 at least big enough. */
1651 = (char *) alloca (tmp.size () + strlen (namestart)
1656 memcpy (tmp1, tmp.c_str (), tmp.size ());
1657 tmp1 += tmp.size ();
1658 memcpy (tmp1, "::", 2);
1660 memcpy (tmp1, namestart, p - namestart);
1661 tmp1[p - namestart] = '\0';
1663 = lookup_symbol (ncopy,
1664 pstate->expression_context_block,
1665 VAR_DOMAIN, NULL).symbol;
1668 if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF)
1686 yylval.tsym.type = SYMBOL_TYPE (best_sym);
1688 yylval.tsym.type = SYMBOL_TYPE (sym);
1694 = language_lookup_primitive_type (pstate->language (),
1695 pstate->gdbarch (), tmp.c_str ());
1696 if (yylval.tsym.type != NULL)
1702 /* Input names that aren't symbols but ARE valid hex numbers,
1703 when the input radix permits them, can be names or numbers
1704 depending on the parse. Note we support radixes > 16 here. */
1706 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1707 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1709 YYSTYPE newlval; /* Its value is ignored. */
1710 hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
1713 yylval.ssym.sym.symbol = sym;
1714 yylval.ssym.sym.block = NULL;
1715 yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL;
1722 /* Any other kind of symbol. */
1723 yylval.ssym.sym.symbol = sym;
1724 yylval.ssym.sym.block = NULL;
1729 /* See language.h. */
1732 pascal_language::parser (struct parser_state *par_state) const
1734 /* Setting up the parser state. */
1735 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1736 gdb_assert (par_state != NULL);
1744 yyerror (const char *msg)
1746 if (pstate->prev_lexptr)
1747 pstate->lexptr = pstate->prev_lexptr;
1749 error (_("A %s in expression, near `%s'."), msg, pstate->lexptr);