1 /* YACC parser for Pascal expressions, for GDB.
2 Copyright (C) 2000-2024 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"
56 #define parse_type(ps) builtin_type (ps->gdbarch ())
58 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
60 #define GDB_YY_REMAP_PREFIX pascal_
63 /* The state of the parser, used internally when we are parsing the
66 static struct parser_state
*pstate
= NULL
;
68 /* Depth of parentheses. */
69 static int paren_depth
;
73 static int yylex (void);
75 static void yyerror (const char *);
77 static char *uptok
(const char *, int);
82 /* Although the yacc "value" of an expression is not used,
83 since the result is stored in the structure being created,
84 other node types do have values. */
101 struct symtoken ssym
;
103 const struct block
*bval
;
104 enum exp_opcode opcode
;
105 struct internalvar
*ivar
;
112 /* YYSTYPE gets defined by %union */
113 static int parse_number
(struct parser_state
*,
114 const char *, int, int, YYSTYPE *);
116 static struct type
*current_type
;
117 static int leftdiv_is_integer
;
118 static void push_current_type
(void);
119 static void pop_current_type
(void);
120 static int search_field
;
123 %type
<voidval
> exp exp1 type_exp start normal_start variable qualified_name
124 %type
<tval
> type typebase
125 /* %type <bval> block */
127 /* Fancy type parsing. */
130 %token
<typed_val_int
> INT
131 %token
<typed_val_float
> FLOAT
133 /* Both NAME and TYPENAME tokens represent symbols in the input,
134 and both convey their data as strings.
135 But a TYPENAME is a string that happens to be defined as a typedef
136 or builtin type name (such as int or char)
137 and a NAME is any other symbol.
138 Contexts where this distinction is not important can use the
139 nonterminal "name", which matches either NAME or TYPENAME. */
142 %token
<sval
> FIELDNAME
143 %token
<voidval
> COMPLETE
144 %token
<ssym
> NAME
/* BLOCKNAME defined below to give it higher precedence. */
145 %token
<tsym
> TYPENAME
147 %type
<ssym
> name_not_typename
149 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
150 but which would parse as a valid number in the current input radix.
151 E.g. "c" when input_radix==16. Depending on the parse, it will be
152 turned into a name or into a number. */
154 %token
<ssym
> NAME_OR_INT
156 %token STRUCT CLASS SIZEOF COLONCOLON
159 /* Special type cases, put in to allow the parser to distinguish different
162 %token
<sval
> DOLLAR_VARIABLE
167 %token
<lval
> TRUEKEYWORD FALSEKEYWORD
177 %left
'<' '>' LEQ GEQ
178 %left LSH RSH DIV MOD
182 %right UNARY INCREMENT DECREMENT
183 %right ARROW
'.' '[' '('
185 %token
<ssym
> BLOCKNAME
192 start
: { current_type
= NULL
;
194 leftdiv_is_integer
= 0;
206 pstate
->push_new
<type_operation
> ($1);
207 current_type
= $1; } ;
209 /* Expressions, including the comma operator. */
212 { pstate
->wrap2
<comma_operation
> (); }
215 /* Expressions, not including the comma operator. */
216 exp
: exp
'^' %prec UNARY
217 { pstate
->wrap
<unop_ind_operation
> ();
219 current_type
= current_type
->target_type
(); }
222 exp
: '@' exp %prec UNARY
223 { pstate
->wrap
<unop_addr_operation
> ();
225 current_type
= TYPE_POINTER_TYPE
(current_type
); }
228 exp
: '-' exp %prec UNARY
229 { pstate
->wrap
<unary_neg_operation
> (); }
232 exp
: NOT exp %prec UNARY
233 { pstate
->wrap
<unary_logical_not_operation
> (); }
236 exp
: INCREMENT
'(' exp
')' %prec UNARY
237 { pstate
->wrap
<preinc_operation
> (); }
240 exp
: DECREMENT
'(' exp
')' %prec UNARY
241 { pstate
->wrap
<predec_operation
> (); }
245 field_exp
: exp
'.' %prec UNARY
246 { search_field
= 1; }
249 exp
: field_exp FIELDNAME
251 pstate
->push_new
<structop_operation
>
252 (pstate
->pop
(), copy_name
($2));
256 while
(current_type
->code
()
259 current_type
->target_type
();
260 current_type
= lookup_struct_elt_type
(
261 current_type
, $2.ptr
, 0);
269 pstate
->push_new
<structop_operation
>
270 (pstate
->pop
(), copy_name
($2));
274 while
(current_type
->code
()
277 current_type
->target_type
();
278 current_type
= lookup_struct_elt_type
(
279 current_type
, $2.ptr
, 0);
283 exp
: field_exp name COMPLETE
285 structop_base_operation
*op
286 = new structop_ptr_operation
(pstate
->pop
(),
288 pstate
->mark_struct_expression
(op
);
289 pstate
->push
(operation_up
(op
));
292 exp
: field_exp COMPLETE
294 structop_base_operation
*op
295 = new structop_ptr_operation
(pstate
->pop
(), "");
296 pstate
->mark_struct_expression
(op
);
297 pstate
->push
(operation_up
(op
));
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
);
311 ->field
(arrayfieldindex
- 1).type
());
312 pstate
->push_new
<structop_operation
>
313 (pstate
->pop
(), arrayname
);
315 push_current_type
(); }
317 { pop_current_type
();
318 pstate
->wrap2
<subscript_operation
> ();
320 current_type
= current_type
->target_type
(); }
324 /* This is to save the value of arglist_len
325 being accumulated by an outer function call. */
326 { push_current_type
();
327 pstate
->start_arglist
(); }
328 arglist
')' %prec ARROW
330 std
::vector
<operation_up
> args
331 = pstate
->pop_vector
(pstate
->end_arglist
());
332 pstate
->push_new
<funcall_operation
>
333 (pstate
->pop
(), std
::move
(args
));
336 current_type
= current_type
->target_type
();
342 { pstate
->arglist_len
= 1; }
343 | arglist
',' exp %prec ABOVE_COMMA
344 { pstate
->arglist_len
++; }
347 exp
: type
'(' exp
')' %prec UNARY
350 /* Allow automatic dereference of classes. */
351 if
((current_type
->code
() == TYPE_CODE_PTR
)
352 && (current_type
->target_type
()->code
() == TYPE_CODE_STRUCT
)
353 && (($1)->code
() == TYPE_CODE_STRUCT
))
354 pstate
->wrap
<unop_ind_operation
> ();
356 pstate
->push_new
<unop_cast_operation
>
357 (pstate
->pop
(), $1);
365 /* Binary operators in order of decreasing precedence. */
368 { pstate
->wrap2
<mul_operation
> (); }
372 if
(current_type
&& is_integral_type
(current_type
))
373 leftdiv_is_integer
= 1;
377 if
(leftdiv_is_integer
&& current_type
378 && is_integral_type
(current_type
))
380 pstate
->push_new
<unop_cast_operation
>
382 parse_type
(pstate
)->builtin_long_double
);
384 = parse_type
(pstate
)->builtin_long_double
;
385 leftdiv_is_integer
= 0;
388 pstate
->wrap2
<div_operation
> ();
393 { pstate
->wrap2
<intdiv_operation
> (); }
397 { pstate
->wrap2
<rem_operation
> (); }
401 { pstate
->wrap2
<add_operation
> (); }
405 { pstate
->wrap2
<sub_operation
> (); }
409 { pstate
->wrap2
<lsh_operation
> (); }
413 { pstate
->wrap2
<rsh_operation
> (); }
418 pstate
->wrap2
<equal_operation
> ();
419 current_type
= parse_type
(pstate
)->builtin_bool
;
423 exp
: exp NOTEQUAL exp
425 pstate
->wrap2
<notequal_operation
> ();
426 current_type
= parse_type
(pstate
)->builtin_bool
;
432 pstate
->wrap2
<leq_operation
> ();
433 current_type
= parse_type
(pstate
)->builtin_bool
;
439 pstate
->wrap2
<geq_operation
> ();
440 current_type
= parse_type
(pstate
)->builtin_bool
;
446 pstate
->wrap2
<less_operation
> ();
447 current_type
= parse_type
(pstate
)->builtin_bool
;
453 pstate
->wrap2
<gtr_operation
> ();
454 current_type
= parse_type
(pstate
)->builtin_bool
;
459 { pstate
->wrap2
<bitwise_and_operation
> (); }
463 { pstate
->wrap2
<bitwise_xor_operation
> (); }
467 { pstate
->wrap2
<bitwise_ior_operation
> (); }
471 { pstate
->wrap2
<assign_operation
> (); }
476 pstate
->push_new
<bool_operation
> ($1);
477 current_type
= parse_type
(pstate
)->builtin_bool
;
483 pstate
->push_new
<bool_operation
> ($1);
484 current_type
= parse_type
(pstate
)->builtin_bool
;
490 pstate
->push_new
<long_const_operation
>
492 current_type
= $1.type
;
498 parse_number
(pstate
, $1.stoken.ptr
,
499 $1.stoken.length
, 0, &val
);
500 pstate
->push_new
<long_const_operation
>
501 (val.typed_val_int.type
,
502 val.typed_val_int.val
);
503 current_type
= val.typed_val_int.type
;
511 std
::copy
(std
::begin
($1.val
), std
::end
($1.val
),
513 pstate
->push_new
<float_const_operation
> ($1.type
, data
);
520 exp
: DOLLAR_VARIABLE
522 pstate
->push_dollar
($1);
524 /* $ is the normal prefix for pascal
525 hexadecimal values but this conflicts
526 with the GDB use for debugger variables
527 so in expression to enter hexadecimal
528 values we still need to use C syntax with
530 std
::string tmp
($1.ptr
, $1.length
);
531 /* Handle current_type. */
532 struct internalvar
*intvar
533 = lookup_only_internalvar
(tmp.c_str
() + 1);
534 if
(intvar
!= nullptr
)
536 scoped_value_mark mark
;
539 = value_of_internalvar
(pstate
->gdbarch
(),
541 current_type
= val
->type
();
546 exp
: SIZEOF
'(' type
')' %prec UNARY
548 current_type
= parse_type
(pstate
)->builtin_int
;
549 $3 = check_typedef
($3);
550 pstate
->push_new
<long_const_operation
>
551 (parse_type
(pstate
)->builtin_int
,
555 exp
: SIZEOF
'(' exp
')' %prec UNARY
556 { pstate
->wrap
<unop_sizeof_operation
> ();
557 current_type
= parse_type
(pstate
)->builtin_int
; }
560 { /* C strings are converted into array constants with
561 an explicit null byte added at the end. Thus
562 the array upper bound is the string length.
563 There is no such thing in C as a completely empty
565 const char *sp
= $1.ptr
; int count
= $1.length
;
567 std
::vector
<operation_up
> args
(count
+ 1);
568 for
(int i
= 0; i
< count
; ++i
)
569 args
[i
] = (make_operation
<long_const_operation
>
570 (parse_type
(pstate
)->builtin_char
,
572 args
[count
] = (make_operation
<long_const_operation
>
573 (parse_type
(pstate
)->builtin_char
,
575 pstate
->push_new
<array_operation
>
576 (0, $1.length
, std
::move
(args
));
583 struct value
* this_val
;
584 struct type
* this_type
;
585 pstate
->push_new
<op_this_operation
> ();
586 /* We need type of this. */
588 = value_of_this_silent
(pstate
->language
());
590 this_type
= this_val
->type
();
595 if
(this_type
->code
() == TYPE_CODE_PTR
)
597 this_type
= this_type
->target_type
();
598 pstate
->wrap
<unop_ind_operation
> ();
602 current_type
= this_type
;
606 /* end of object pascal. */
610 if
($1.sym.symbol
!= 0)
611 $$
= $1.sym.symbol
->value_block
();
614 std
::string copy
= copy_name
($1.stoken
);
616 lookup_symtab
(copy.c_str
());
618 $$
= (tem
->compunit
()->blockvector
()
621 error (_
("No file or function \"%s\"."),
627 block
: block COLONCOLON name
629 std
::string copy
= copy_name
($3);
631 = lookup_symbol
(copy.c_str
(), $1,
632 SEARCH_FUNCTION_DOMAIN
,
636 error (_
("No function \"%s\" in specified context."),
638 $$
= tem
->value_block
(); }
641 variable: block COLONCOLON name
642 { struct block_symbol sym
;
644 std
::string copy
= copy_name
($3);
645 sym
= lookup_symbol
(copy.c_str
(), $1,
648 error (_
("No symbol \"%s\" in specified context."),
651 pstate
->push_new
<var_value_operation
> (sym
);
655 qualified_name: typebase COLONCOLON name
657 struct type
*type
= $1;
659 if
(type
->code
() != TYPE_CODE_STRUCT
660 && type
->code
() != TYPE_CODE_UNION
)
661 error (_
("`%s' is not defined as an aggregate type."),
664 pstate
->push_new
<scope_operation
>
665 (type
, copy_name
($3));
669 variable: qualified_name
672 std
::string name
= copy_name
($2);
674 struct block_symbol sym
675 = lookup_symbol
(name.c_str
(), nullptr
,
676 SEARCH_VFT
, nullptr
);
677 pstate
->push_symbol
(name.c_str
(), sym
);
681 variable: name_not_typename
682 { struct block_symbol sym
= $1.sym
;
686 if
(symbol_read_needs_frame
(sym.symbol
))
687 pstate
->block_tracker
->update
(sym
);
689 pstate
->push_new
<var_value_operation
> (sym
);
690 current_type
= sym.symbol
->type
(); }
691 else if
($1.is_a_field_of_this
)
693 struct value
* this_val
;
694 struct type
* this_type
;
695 /* Object pascal: it hangs off of `this'. Must
696 not inadvertently convert from a method call
698 pstate
->block_tracker
->update
(sym
);
700 = make_operation
<op_this_operation
> ();
701 pstate
->push_new
<structop_operation
>
702 (std
::move
(thisop
), copy_name
($1.stoken
));
703 /* We need type of this. */
705 = value_of_this_silent
(pstate
->language
());
707 this_type
= this_val
->type
();
711 current_type
= lookup_struct_elt_type
(
713 copy_name
($1.stoken
).c_str
(), 0);
719 struct bound_minimal_symbol msymbol
;
720 std
::string arg
= copy_name
($1.stoken
);
723 lookup_bound_minimal_symbol
(arg.c_str
());
724 if
(msymbol.minsym
!= NULL
)
725 pstate
->push_new
<var_msym_value_operation
>
727 else if
(!have_full_symbols
()
728 && !have_partial_symbols
())
729 error (_
("No symbol table is loaded. "
730 "Use the \"file\" command."));
732 error (_
("No symbol \"%s\" in current context."),
742 /* We used to try to recognize more pointer to member types here, but
743 that didn't work (shift/reduce conflicts meant that these rules never
744 got executed). The problem is that
745 int (foo::bar::baz::bizzle)
746 is a function type but
747 int (foo::bar::baz::bizzle::*)
748 is a pointer to member type. Stroustrup loses again! */
753 typebase
/* Implements (approximately): (type-qualifier)* type-specifier */
755 { $$
= lookup_pointer_type
($2); }
760 = lookup_struct
(copy_name
($2).c_str
(),
761 pstate
->expression_context_block
);
765 = lookup_struct
(copy_name
($2).c_str
(),
766 pstate
->expression_context_block
);
768 /* "const" and "volatile" are curently ignored. A type qualifier
769 after the type is handled in the ptype rule. I think these could
773 name
: NAME
{ $$
= $1.stoken
; }
774 | BLOCKNAME
{ $$
= $1.stoken
; }
775 | TYPENAME
{ $$
= $1.stoken
; }
776 | NAME_OR_INT
{ $$
= $1.stoken
; }
779 name_not_typename
: NAME
781 /* These would be useful if name_not_typename was useful, but it is just
782 a fake for "variable", so these cause reduce/reduce conflicts because
783 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
784 =exp) or just an exp. If name_not_typename was ever used in an lvalue
785 context where only a name could occur, this might be useful.
792 /* Take care of parsing a number (anything that starts with a digit).
793 Set yylval and return the token type; update lexptr.
794 LEN is the number of characters in it. */
796 /*** Needs some error checking for the float case ***/
799 parse_number
(struct parser_state
*par_state
,
800 const char *p
, int len
, int parsed_float
, YYSTYPE *putithere
)
807 int base
= input_radix
;
810 /* Number of "L" suffixes encountered. */
813 /* We have found a "L" or "U" suffix. */
814 int found_suffix
= 0;
818 /* Handle suffixes: 'f' for float, 'l' for long double.
819 FIXME: This appears to be an extension -- do we want this? */
820 if
(len
>= 1 && tolower
(p
[len
- 1]) == 'f')
822 putithere
->typed_val_float.type
823 = parse_type
(par_state
)->builtin_float
;
826 else if
(len
>= 1 && tolower
(p
[len
- 1]) == 'l')
828 putithere
->typed_val_float.type
829 = parse_type
(par_state
)->builtin_long_double
;
832 /* Default type for floating-point literals is double. */
835 putithere
->typed_val_float.type
836 = parse_type
(par_state
)->builtin_double
;
839 if
(!parse_float
(p
, len
,
840 putithere
->typed_val_float.type
,
841 putithere
->typed_val_float.val
))
846 /* Handle base-switching prefixes 0x, 0t, 0d, 0. */
847 if
(p
[0] == '0' && len
> 1)
880 if
(c
>= 'A' && c
<= 'Z')
882 if
(c
!= 'l' && c
!= 'u')
884 if
(c
>= '0' && c
<= '9')
892 if
(base
> 10 && c
>= 'a' && c
<= 'f')
896 n
+= i
= c
- 'a' + 10;
909 return ERROR
; /* Char not a digit */
912 return ERROR
; /* Invalid digit in this base. */
914 if
(c
!= 'l' && c
!= 'u')
916 /* Test for overflow. */
917 if
(prevn
== 0 && n
== 0)
920 error (_
("Numeric constant too large."));
925 /* An integer constant is an int, a long, or a long long. An L
926 suffix forces it to be long; an LL suffix forces it to be long
927 long. If not forced to a larger size, it gets the first type of
928 the above that it fits in. To figure out whether it fits, we
929 shift it right and see whether anything remains. Note that we
930 can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
931 operation, because many compilers will warn about such a shift
932 (which always produces a zero result). Sometimes gdbarch_int_bit
933 or gdbarch_long_bit will be that big, sometimes not. To deal with
934 the case where it is we just always shift the value more than
935 once, with fewer bits each time. */
937 int int_bits
= gdbarch_int_bit
(par_state
->gdbarch
());
938 int long_bits
= gdbarch_long_bit
(par_state
->gdbarch
());
939 int long_long_bits
= gdbarch_long_long_bit
(par_state
->gdbarch
());
940 bool have_signed
= !unsigned_p
;
941 bool have_int
= long_p
== 0;
942 bool have_long
= long_p
<= 1;
943 if
(have_int
&& have_signed
&& fits_in_type
(1, n
, int_bits
, true
))
944 putithere
->typed_val_int.type
= parse_type
(par_state
)->builtin_int
;
945 else if
(have_int
&& fits_in_type
(1, n
, int_bits
, false
))
946 putithere
->typed_val_int.type
947 = parse_type
(par_state
)->builtin_unsigned_int
;
948 else if
(have_long
&& have_signed
&& fits_in_type
(1, n
, long_bits
, true
))
949 putithere
->typed_val_int.type
= parse_type
(par_state
)->builtin_long
;
950 else if
(have_long
&& fits_in_type
(1, n
, long_bits
, false
))
951 putithere
->typed_val_int.type
952 = parse_type
(par_state
)->builtin_unsigned_long
;
953 else if
(have_signed
&& fits_in_type
(1, n
, long_long_bits
, true
))
954 putithere
->typed_val_int.type
955 = parse_type
(par_state
)->builtin_long_long
;
956 else if
(fits_in_type
(1, n
, long_long_bits
, false
))
957 putithere
->typed_val_int.type
958 = parse_type
(par_state
)->builtin_unsigned_long_long
;
960 error (_
("Numeric constant too large."));
961 putithere
->typed_val_int.val
= n
;
970 struct type_push
*next
;
973 static struct type_push
*tp_top
= NULL
;
976 push_current_type
(void)
978 struct type_push
*tpnew
;
979 tpnew
= (struct type_push
*) malloc
(sizeof
(struct type_push
));
980 tpnew
->next
= tp_top
;
981 tpnew
->stored
= current_type
;
987 pop_current_type
(void)
989 struct type_push
*tp
= tp_top
;
992 current_type
= tp
->stored
;
1002 enum exp_opcode opcode
;
1005 static const struct p_token tokentab3
[] =
1007 {"shr", RSH
, OP_NULL
},
1008 {"shl", LSH
, OP_NULL
},
1009 {"and", ANDAND
, OP_NULL
},
1010 {"div", DIV
, OP_NULL
},
1011 {"not", NOT
, OP_NULL
},
1012 {"mod", MOD
, OP_NULL
},
1013 {"inc", INCREMENT
, OP_NULL
},
1014 {"dec", DECREMENT
, OP_NULL
},
1015 {"xor", XOR
, OP_NULL
}
1018 static const struct p_token tokentab2
[] =
1020 {"or", OR
, OP_NULL
},
1021 {"<>", NOTEQUAL
, OP_NULL
},
1022 {"<=", LEQ
, OP_NULL
},
1023 {">=", GEQ
, OP_NULL
},
1024 {":=", ASSIGN
, OP_NULL
},
1025 {"::", COLONCOLON
, OP_NULL
} };
1027 /* Allocate uppercased var: */
1028 /* make an uppercased copy of tokstart. */
1030 uptok
(const char *tokstart
, int namelen
)
1033 char *uptokstart
= (char *)malloc
(namelen
+1);
1034 for
(i
= 0;i
<= namelen
;i
++)
1036 if
((tokstart
[i
]>='a' && tokstart
[i
]<='z'))
1037 uptokstart
[i
] = tokstart
[i
]-('a'-'A');
1039 uptokstart
[i
] = tokstart
[i
];
1041 uptokstart
[namelen
]='\0';
1045 /* Read one token, getting characters through lexptr. */
1052 const char *tokstart
;
1055 int explen
, tempbufindex
;
1056 static char *tempbuf
;
1057 static int tempbufsize
;
1061 pstate
->prev_lexptr
= pstate
->lexptr
;
1063 tokstart
= pstate
->lexptr
;
1064 explen
= strlen
(pstate
->lexptr
);
1066 /* See if it is a special token of length 3. */
1068 for
(const auto
&token
: tokentab3
)
1069 if
(strncasecmp
(tokstart
, token.oper
, 3) == 0
1070 && (!isalpha
(token.oper
[0]) || explen
== 3
1071 ||
(!isalpha
(tokstart
[3])
1072 && !isdigit
(tokstart
[3]) && tokstart
[3] != '_')))
1074 pstate
->lexptr
+= 3;
1075 yylval.opcode
= token.opcode
;
1079 /* See if it is a special token of length 2. */
1081 for
(const auto
&token
: tokentab2
)
1082 if
(strncasecmp
(tokstart
, token.oper
, 2) == 0
1083 && (!isalpha
(token.oper
[0]) || explen
== 2
1084 ||
(!isalpha
(tokstart
[2])
1085 && !isdigit
(tokstart
[2]) && tokstart
[2] != '_')))
1087 pstate
->lexptr
+= 2;
1088 yylval.opcode
= token.opcode
;
1092 switch
(c
= *tokstart
)
1095 if
(search_field
&& pstate
->parse_completion
)
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
1111 c
= *pstate
->lexptr
++;
1113 c
= parse_escape
(pstate
->gdbarch
(), &pstate
->lexptr
);
1115 error (_
("Empty character constant."));
1117 yylval.typed_val_int.val
= c
;
1118 yylval.typed_val_int.type
= parse_type
(pstate
)->builtin_char
;
1120 c
= *pstate
->lexptr
++;
1123 namelen
= skip_quoted
(tokstart
) - tokstart
;
1126 pstate
->lexptr
= tokstart
+ namelen
;
1127 if
(pstate
->lexptr
[-1] != '\'')
1128 error (_
("Unmatched single quote."));
1131 uptokstart
= uptok
(tokstart
,namelen
);
1134 error (_
("Invalid character constant."));
1144 if
(paren_depth
== 0)
1151 if
(pstate
->comma_terminates
&& paren_depth
== 0)
1157 /* Might be a floating point number. */
1158 if
(pstate
->lexptr
[1] < '0' || pstate
->lexptr
[1] > '9')
1160 goto symbol
; /* Nope, must be a symbol. */
1176 /* It's a number. */
1177 int got_dot
= 0, got_e
= 0, toktype
;
1178 const char *p
= tokstart
;
1179 int hex
= input_radix
> 10;
1181 if
(c
== '0' && (p
[1] == 'x' || p
[1] == 'X'))
1186 else if
(c
== '0' && (p
[1]=='t' || p
[1]=='T'
1187 || p
[1]=='d' || p
[1]=='D'))
1195 /* This test includes !hex because 'e' is a valid hex digit
1196 and thus does not indicate a floating point number when
1197 the radix is hex. */
1198 if
(!hex
&& !got_e
&& (*p
== 'e' ||
*p
== 'E'))
1199 got_dot
= got_e
= 1;
1200 /* This test does not include !hex, because a '.' always indicates
1201 a decimal floating point number regardless of the radix. */
1202 else if
(!got_dot
&& *p
== '.')
1204 else if
(got_e
&& (p
[-1] == 'e' || p
[-1] == 'E')
1205 && (*p
== '-' ||
*p
== '+'))
1206 /* This is the sign of the exponent, not the end of the
1209 /* We will take any letters or digits. parse_number will
1210 complain if past the radix, or if L or U are not final. */
1211 else if
((*p
< '0' ||
*p
> '9')
1212 && ((*p
< 'a' ||
*p
> 'z')
1213 && (*p
< 'A' ||
*p
> 'Z')))
1216 toktype
= parse_number
(pstate
, tokstart
,
1217 p
- tokstart
, got_dot | got_e
, &yylval);
1218 if
(toktype
== ERROR
)
1220 char *err_copy
= (char *) alloca
(p
- tokstart
+ 1);
1222 memcpy
(err_copy
, tokstart
, p
- tokstart
);
1223 err_copy
[p
- tokstart
] = 0;
1224 error (_
("Invalid number \"%s\"."), err_copy
);
1255 /* Build the gdb internal form of the input string in tempbuf,
1256 translating any standard C escape forms seen. Note that the
1257 buffer is null byte terminated *only* for the convenience of
1258 debugging gdb itself and printing the buffer contents when
1259 the buffer contains no embedded nulls. Gdb does not depend
1260 upon the buffer being null byte terminated, it uses the length
1261 string instead. This allows gdb to handle C strings (as well
1262 as strings in other languages) with embedded null bytes. */
1264 tokptr
= ++tokstart
;
1268 /* Grow the static temp buffer if necessary, including allocating
1269 the first one on demand. */
1270 if
(tempbufindex
+ 1 >= tempbufsize
)
1272 tempbuf
= (char *) realloc
(tempbuf
, tempbufsize
+= 64);
1279 /* Do nothing, loop will terminate. */
1283 c
= parse_escape
(pstate
->gdbarch
(), &tokptr
);
1288 tempbuf
[tempbufindex
++] = c
;
1291 tempbuf
[tempbufindex
++] = *tokptr
++;
1294 } while
((*tokptr
!= '"') && (*tokptr
!= '\0'));
1295 if
(*tokptr
++ != '"')
1297 error (_
("Unterminated string in expression."));
1299 tempbuf
[tempbufindex
] = '\0'; /* See note above. */
1300 yylval.sval.ptr
= tempbuf
;
1301 yylval.sval.length
= tempbufindex
;
1302 pstate
->lexptr
= tokptr
;
1306 if
(!(c
== '_' || c
== '$'
1307 ||
(c
>= 'a' && c
<= 'z') ||
(c
>= 'A' && c
<= 'Z')))
1308 /* We must have come across a bad character (e.g. ';'). */
1309 error (_
("Invalid character '%c' in expression."), c
);
1311 /* It's a name. See how long it is. */
1313 for
(c
= tokstart
[namelen
];
1314 (c
== '_' || c
== '$' ||
(c
>= '0' && c
<= '9')
1315 ||
(c
>= 'a' && c
<= 'z') ||
(c
>= 'A' && c
<= 'Z') || c
== '<');)
1317 /* Template parameter lists are part of the name.
1318 FIXME: This mishandles `print $a<4&&$a>3'. */
1322 int nesting_level
= 1;
1323 while
(tokstart
[++i
])
1325 if
(tokstart
[i
] == '<')
1327 else if
(tokstart
[i
] == '>')
1329 if
(--nesting_level
== 0)
1333 if
(tokstart
[i
] == '>')
1339 /* do NOT uppercase internals because of registers !!! */
1340 c
= tokstart
[++namelen
];
1343 uptokstart
= uptok
(tokstart
,namelen
);
1345 /* The token "if" terminates the expression and is NOT
1346 removed from the input stream. */
1347 if
(namelen
== 2 && uptokstart
[0] == 'I' && uptokstart
[1] == 'F')
1353 pstate
->lexptr
+= namelen
;
1357 /* Catch specific keywords. Should be done with a data structure. */
1361 if
(strcmp
(uptokstart
, "OBJECT") == 0)
1366 if
(strcmp
(uptokstart
, "RECORD") == 0)
1371 if
(strcmp
(uptokstart
, "SIZEOF") == 0)
1378 if
(strcmp
(uptokstart
, "CLASS") == 0)
1383 if
(strcmp
(uptokstart
, "FALSE") == 0)
1387 return FALSEKEYWORD
;
1391 if
(strcmp
(uptokstart
, "TRUE") == 0)
1397 if
(strcmp
(uptokstart
, "SELF") == 0)
1399 /* Here we search for 'this' like
1400 inserted in FPC stabs debug info. */
1401 static const char this_name
[] = "this";
1403 if
(lookup_symbol
(this_name
, pstate
->expression_context_block
,
1404 SEARCH_VFT
, NULL
).symbol
)
1415 yylval.sval.ptr
= tokstart
;
1416 yylval.sval.length
= namelen
;
1418 if
(*tokstart
== '$')
1421 return DOLLAR_VARIABLE
;
1424 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1425 functions or symtabs. If this is not so, then ...
1426 Use token-type TYPENAME for symbols that happen to be defined
1427 currently as names of types; NAME for other symbols.
1428 The caller is not constrained to care about the distinction. */
1430 std
::string tmp
= copy_name
(yylval.sval
);
1432 struct field_of_this_result is_a_field_of_this
;
1436 is_a_field_of_this.type
= NULL
;
1437 if
(search_field
&& current_type
)
1438 is_a_field
= (lookup_struct_elt_type
(current_type
,
1439 tmp.c_str
(), 1) != NULL
);
1443 sym
= lookup_symbol
(tmp.c_str
(), pstate
->expression_context_block
,
1444 SEARCH_VFT
, &is_a_field_of_this
).symbol
;
1445 /* second chance uppercased (as Free Pascal does). */
1446 if
(!sym
&& is_a_field_of_this.type
== NULL
&& !is_a_field
)
1448 for
(int i
= 0; i
<= namelen
; i
++)
1450 if
((tmp
[i
] >= 'a' && tmp
[i
] <= 'z'))
1451 tmp
[i
] -= ('a'-'A');
1453 if
(search_field
&& current_type
)
1454 is_a_field
= (lookup_struct_elt_type
(current_type
,
1455 tmp.c_str
(), 1) != NULL
);
1459 sym
= lookup_symbol
(tmp.c_str
(), pstate
->expression_context_block
,
1460 SEARCH_VFT
, &is_a_field_of_this
).symbol
;
1462 /* Third chance Capitalized (as GPC does). */
1463 if
(!sym
&& is_a_field_of_this.type
== NULL
&& !is_a_field
)
1465 for
(int i
= 0; i
<= namelen
; i
++)
1469 if
((tmp
[i
] >= 'a' && tmp
[i
] <= 'z'))
1470 tmp
[i
] -= ('a'-'A');
1473 if
((tmp
[i
] >= 'A' && tmp
[i
] <= 'Z'))
1474 tmp
[i
] -= ('A'-'a');
1476 if
(search_field
&& current_type
)
1477 is_a_field
= (lookup_struct_elt_type
(current_type
,
1478 tmp.c_str
(), 1) != NULL
);
1482 sym
= lookup_symbol
(tmp.c_str
(), pstate
->expression_context_block
,
1483 SEARCH_VFT
, &is_a_field_of_this
).symbol
;
1486 if
(is_a_field ||
(is_a_field_of_this.type
!= NULL
))
1488 tempbuf
= (char *) realloc
(tempbuf
, namelen
+ 1);
1489 strncpy
(tempbuf
, tmp.c_str
(), namelen
);
1490 tempbuf
[namelen
] = 0;
1491 yylval.sval.ptr
= tempbuf
;
1492 yylval.sval.length
= namelen
;
1493 yylval.ssym.sym.symbol
= NULL
;
1494 yylval.ssym.sym.block
= NULL
;
1496 yylval.ssym.is_a_field_of_this
= is_a_field_of_this.type
!= NULL
;
1502 /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1503 no psymtabs (coff, xcoff, or some future change to blow away the
1504 psymtabs once once symbols are read). */
1505 if
((sym
&& sym
->aclass
() == LOC_BLOCK
)
1506 || lookup_symtab
(tmp.c_str
()))
1508 yylval.ssym.sym.symbol
= sym
;
1509 yylval.ssym.sym.block
= NULL
;
1510 yylval.ssym.is_a_field_of_this
= is_a_field_of_this.type
!= NULL
;
1514 if
(sym
&& sym
->aclass
() == LOC_TYPEDEF
)
1517 /* Despite the following flaw, we need to keep this code enabled.
1518 Because we can get called from check_stub_method, if we don't
1519 handle nested types then it screws many operations in any
1520 program which uses nested types. */
1521 /* In "A::x", if x is a member function of A and there happens
1522 to be a type (nested or not, since the stabs don't make that
1523 distinction) named x, then this code incorrectly thinks we
1524 are dealing with nested types rather than a member function. */
1527 const char *namestart
;
1528 struct symbol
*best_sym
;
1530 /* Look ahead to detect nested types. This probably should be
1531 done in the grammar, but trying seemed to introduce a lot
1532 of shift/reduce and reduce/reduce conflicts. It's possible
1533 that it could be done, though. Or perhaps a non-grammar, but
1534 less ad hoc, approach would work well. */
1536 /* Since we do not currently have any way of distinguishing
1537 a nested type from a non-nested one (the stabs don't tell
1538 us whether a type is nested), we just ignore the
1545 /* Skip whitespace. */
1546 while
(*p
== ' ' ||
*p
== '\t' ||
*p
== '\n')
1548 if
(*p
== ':' && p
[1] == ':')
1550 /* Skip the `::'. */
1552 /* Skip whitespace. */
1553 while
(*p
== ' ' ||
*p
== '\t' ||
*p
== '\n')
1556 while
(*p
== '_' ||
*p
== '$' ||
(*p
>= '0' && *p
<= '9')
1557 ||
(*p
>= 'a' && *p
<= 'z')
1558 ||
(*p
>= 'A' && *p
<= 'Z'))
1562 struct symbol
*cur_sym
;
1563 /* As big as the whole rest of the expression, which is
1564 at least big enough. */
1566 = (char *) alloca
(tmp.size
() + strlen
(namestart
)
1571 memcpy
(tmp1
, tmp.c_str
(), tmp.size
());
1572 tmp1
+= tmp.size
();
1573 memcpy
(tmp1
, "::", 2);
1575 memcpy
(tmp1
, namestart
, p
- namestart
);
1576 tmp1
[p
- namestart
] = '\0';
1578 = lookup_symbol
(ncopy
,
1579 pstate
->expression_context_block
,
1580 SEARCH_VFT
, NULL
).symbol
;
1583 if
(cur_sym
->aclass
() == LOC_TYPEDEF
)
1601 yylval.tsym.type
= best_sym
->type
();
1603 yylval.tsym.type
= sym
->type
();
1609 = language_lookup_primitive_type
(pstate
->language
(),
1610 pstate
->gdbarch
(), tmp.c_str
());
1611 if
(yylval.tsym.type
!= NULL
)
1617 /* Input names that aren't symbols but ARE valid hex numbers,
1618 when the input radix permits them, can be names or numbers
1619 depending on the parse. Note we support radixes > 16 here. */
1621 && ((tokstart
[0] >= 'a' && tokstart
[0] < 'a' + input_radix
- 10)
1622 ||
(tokstart
[0] >= 'A' && tokstart
[0] < 'A' + input_radix
- 10)))
1624 YYSTYPE newlval
; /* Its value is ignored. */
1625 hextype
= parse_number
(pstate
, tokstart
, namelen
, 0, &newlval
);
1628 yylval.ssym.sym.symbol
= sym
;
1629 yylval.ssym.sym.block
= NULL
;
1630 yylval.ssym.is_a_field_of_this
= is_a_field_of_this.type
!= NULL
;
1637 /* Any other kind of symbol. */
1638 yylval.ssym.sym.symbol
= sym
;
1639 yylval.ssym.sym.block
= NULL
;
1644 /* See language.h. */
1647 pascal_language::parser
(struct parser_state
*par_state
) const
1649 /* Setting up the parser state. */
1650 scoped_restore pstate_restore
= make_scoped_restore
(&pstate
);
1651 gdb_assert
(par_state
!= NULL
);
1655 int result
= yyparse ();
1657 pstate
->set_operation
(pstate
->pop
());
1662 yyerror (const char *msg
)
1664 pstate
->parse_error
(msg
);