1 /* YACC parser for Ada expressions, for GDB.
2 Copyright (C) 1986-2021 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 /* Parse an Ada expression from text in a string,
20 and return the result as a struct expression pointer.
21 That structure contains arithmetic operations in reverse polish,
22 with constants represented by operations that are followed by special data.
23 See expression.h for the details of the format.
24 What is important here is that it can be built up sequentially
25 during the process of parsing; the lower levels of the tree always
26 come first in the result.
28 malloc's and realloc's in this file are transformed to
29 xmalloc and xrealloc respectively by the same sed command in the
30 makefile that remaps any other malloc/realloc inserted by the parser
31 generator. Doing this with #defines and trying to control the interaction
32 with include files (<malloc.h> and <stdlib.h> for example) just became
33 too messy, particularly when such includes can be inserted at random
34 times by the parser generator. */
40 #include "expression.h"
42 #include "parser-defs.h"
45 #include "bfd.h" /* Required by objfiles.h. */
46 #include "symfile.h" /* Required by objfiles.h. */
47 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52 #define parse_type(ps) builtin_type (ps->gdbarch ())
54 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
56 #define GDB_YY_REMAP_PREFIX ada_
61 struct minimal_symbol *msym;
62 const struct block *block;
66 /* The state of the parser, used internally when we are parsing the
69 static struct parser_state *pstate = NULL;
73 static int yylex (void);
75 static void yyerror (const char *);
77 static void write_int (struct parser_state *, LONGEST, struct type *);
79 static void write_object_renaming (struct parser_state *,
80 const struct block *, const char *, int,
83 static struct type* write_var_or_type (struct parser_state *,
84 const struct block *, struct stoken);
86 static void write_name_assoc (struct parser_state *, struct stoken);
88 static const struct block *block_lookup (const struct block *, const char *);
90 static void write_ambiguous_var (struct parser_state *,
91 const struct block *, const char *, int);
93 static struct type *type_int (struct parser_state *);
95 static struct type *type_long (struct parser_state *);
97 static struct type *type_long_long (struct parser_state *);
99 static struct type *type_long_double (struct parser_state *);
101 static struct type *type_char (struct parser_state *);
103 static struct type *type_boolean (struct parser_state *);
105 static struct type *type_system_address (struct parser_state *);
107 using namespace expr;
109 /* Handle Ada type resolution for OP. DEPROCEDURE_P and CONTEXT_TYPE
110 are passed to the resolve method, if called. */
112 resolve (operation_up &&op, bool deprocedure_p, struct type *context_type)
114 operation_up result = std::move (op);
115 ada_resolvable *res = dynamic_cast<ada_resolvable *> (result.get ());
117 return res->replace (std::move (result),
118 pstate->expout.get (),
120 pstate->parse_completion,
121 pstate->block_tracker,
126 /* Like parser_state::pop, but handles Ada type resolution.
127 DEPROCEDURE_P and CONTEXT_TYPE are passed to the resolve method, if
130 ada_pop (bool deprocedure_p = true, struct type *context_type = nullptr)
132 /* Of course it's ok to call parser_state::pop here... */
133 return resolve (pstate->pop (), deprocedure_p, context_type);
136 /* Like parser_state::wrap, but use ada_pop to pop the value. */
141 operation_up arg = ada_pop ();
142 pstate->push_new<T> (std::move (arg));
145 /* Create and push an address-of operation, as appropriate for Ada.
146 If TYPE is not NULL, the resulting operation will be wrapped in a
149 ada_addrof (struct type *type = nullptr)
151 operation_up arg = ada_pop (false);
152 operation_up addr = make_operation<unop_addr_operation> (std::move (arg));
154 = make_operation<ada_wrapped_operation> (std::move (addr));
156 wrapped = make_operation<unop_cast_operation> (std::move (wrapped), type);
157 pstate->push (std::move (wrapped));
160 /* Handle operator overloading. Either returns a function all
161 operation wrapping the arguments, or it returns null, leaving the
162 caller to construct the appropriate operation. If RHS is null, a
163 unary operator is assumed. */
165 maybe_overload (enum exp_opcode op, operation_up &lhs, operation_up &rhs)
167 struct value *args[2];
170 args[0] = lhs->evaluate (nullptr, pstate->expout.get (),
171 EVAL_AVOID_SIDE_EFFECTS);
176 args[1] = rhs->evaluate (nullptr, pstate->expout.get (),
177 EVAL_AVOID_SIDE_EFFECTS);
181 block_symbol fn = ada_find_operator_symbol (op, pstate->parse_completion,
183 if (fn.symbol == nullptr)
186 if (symbol_read_needs_frame (fn.symbol))
187 pstate->block_tracker->update (fn.block, INNERMOST_BLOCK_FOR_SYMBOLS);
188 operation_up callee = make_operation<ada_var_value_operation> (fn);
190 std::vector<operation_up> argvec;
191 argvec.push_back (std::move (lhs));
193 argvec.push_back (std::move (rhs));
194 return make_operation<ada_funcall_operation> (std::move (callee),
198 /* Like parser_state::wrap, but use ada_pop to pop the value, and
199 handle unary overloading. */
202 ada_wrap_overload (enum exp_opcode op)
204 operation_up arg = ada_pop ();
207 operation_up call = maybe_overload (op, arg, empty);
209 call = make_operation<T> (std::move (arg));
210 pstate->push (std::move (call));
213 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
214 operands, and then pushes a new Ada-wrapped operation of the
218 ada_un_wrap2 (enum exp_opcode op)
220 operation_up rhs = ada_pop ();
221 operation_up lhs = ada_pop ();
223 operation_up wrapped = maybe_overload (op, lhs, rhs);
224 if (wrapped == nullptr)
226 wrapped = make_operation<T> (std::move (lhs), std::move (rhs));
227 wrapped = make_operation<ada_wrapped_operation> (std::move (wrapped));
229 pstate->push (std::move (wrapped));
232 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
233 operands. Unlike ada_un_wrap2, ada_wrapped_operation is not
237 ada_wrap2 (enum exp_opcode op)
239 operation_up rhs = ada_pop ();
240 operation_up lhs = ada_pop ();
241 operation_up call = maybe_overload (op, lhs, rhs);
243 call = make_operation<T> (std::move (lhs), std::move (rhs));
244 pstate->push (std::move (call));
247 /* A variant of parser_state::wrap2 that uses ada_pop to pop both
248 operands. OP is also passed to the constructor of the new binary
252 ada_wrap_op (enum exp_opcode op)
254 operation_up rhs = ada_pop ();
255 operation_up lhs = ada_pop ();
256 operation_up call = maybe_overload (op, lhs, rhs);
258 call = make_operation<T> (op, std::move (lhs), std::move (rhs));
259 pstate->push (std::move (call));
262 /* Pop three operands using ada_pop, then construct a new ternary
263 operation of type T and push it. */
268 operation_up rhs = ada_pop ();
269 operation_up mid = ada_pop ();
270 operation_up lhs = ada_pop ();
271 pstate->push_new<T> (std::move (lhs), std::move (mid), std::move (rhs));
274 /* Pop NARGS operands, then a callee operand, and use these to
275 construct and push a new Ada function call operation. */
277 ada_funcall (int nargs)
279 /* We use the ordinary pop here, because we're going to do
280 resolution in a separate step, in order to handle array
282 std::vector<operation_up> args = pstate->pop_vector (nargs);
283 /* Call parser_state::pop here, because we don't want to
284 function-convert the callee slot of a call we're already
286 operation_up callee = pstate->pop ();
288 ada_var_value_operation *vvo
289 = dynamic_cast<ada_var_value_operation *> (callee.get ());
291 struct type *callee_t = nullptr;
293 || SYMBOL_DOMAIN (vvo->get_symbol ()) != UNDEF_DOMAIN)
295 struct value *callee_v = callee->evaluate (nullptr,
296 pstate->expout.get (),
297 EVAL_AVOID_SIDE_EFFECTS);
298 callee_t = ada_check_typedef (value_type (callee_v));
299 array_arity = ada_array_arity (callee_t);
302 for (int i = 0; i < nargs; ++i)
304 struct type *subtype = nullptr;
306 subtype = ada_index_type (callee_t, i + 1, "array type");
307 args[i] = resolve (std::move (args[i]), true, subtype);
310 std::unique_ptr<ada_funcall_operation> funcall
311 (new ada_funcall_operation (std::move (callee), std::move (args)));
312 funcall->resolve (pstate->expout.get (), true, pstate->parse_completion,
313 pstate->block_tracker, nullptr);
314 pstate->push (std::move (funcall));
317 /* The components being constructed during this parse. */
318 static std::vector<ada_component_up> components;
320 /* Create a new ada_component_up of the indicated type and arguments,
321 and push it on the global 'components' vector. */
322 template<typename T, typename... Arg>
324 push_component (Arg... args)
326 components.emplace_back (new T (std::forward<Arg> (args)...));
329 /* Examine the final element of the 'components' vector, and return it
330 as a pointer to an ada_choices_component. The caller is
331 responsible for ensuring that the final element is in fact an
332 ada_choices_component. */
333 static ada_choices_component *
336 ada_component *last = components.back ().get ();
337 ada_choices_component *result = dynamic_cast<ada_choices_component *> (last);
338 gdb_assert (result != nullptr);
342 /* Pop the most recent component from the global stack, and return
344 static ada_component_up
347 ada_component_up result = std::move (components.back ());
348 components.pop_back ();
352 /* Pop the N most recent components from the global stack, and return
354 static std::vector<ada_component_up>
355 pop_components (int n)
357 std::vector<ada_component_up> result (n);
358 for (int i = 1; i <= n; ++i)
359 result[n - i] = pop_component ();
363 /* The associations being constructed during this parse. */
364 static std::vector<ada_association_up> associations;
366 /* Create a new ada_association_up of the indicated type and
367 arguments, and push it on the global 'associations' vector. */
368 template<typename T, typename... Arg>
370 push_association (Arg... args)
372 associations.emplace_back (new T (std::forward<Arg> (args)...));
375 /* Pop the most recent association from the global stack, and return
377 static ada_association_up
380 ada_association_up result = std::move (associations.back ());
381 associations.pop_back ();
385 /* Pop the N most recent associations from the global stack, and
386 return them in a vector. */
387 static std::vector<ada_association_up>
388 pop_associations (int n)
390 std::vector<ada_association_up> result (n);
391 for (int i = 1; i <= n; ++i)
392 result[n - i] = pop_association ();
411 const struct block *bval;
412 struct internalvar *ivar;
415 %type <lval> positional_list component_groups component_associations
416 %type <lval> aggregate_component_list
417 %type <tval> var_or_type type_prefix opt_type_prefix
419 %token <typed_val> INT NULL_PTR CHARLIT
420 %token <typed_val_float> FLOAT
421 %token TRUEKEYWORD FALSEKEYWORD
423 %token <sval> STRING NAME DOT_ID
425 %type <lval> arglist tick_arglist
429 /* Special type cases, put in to allow the parser to distinguish different
431 %token <sval> DOLLAR_VARIABLE
434 %left _AND_ OR XOR THEN ELSE
435 %left '=' NOTEQUAL '<' '>' LEQ GEQ IN DOTDOT
439 %left '*' '/' MOD REM
440 %right STARSTAR ABS NOT
442 /* Artificial token to give NAME => ... and NAME | priority over reducing
443 NAME to <primary> and to give <primary>' priority over reducing <primary>
449 %right TICK_ACCESS TICK_ADDRESS TICK_FIRST TICK_LAST TICK_LENGTH
450 %right TICK_MAX TICK_MIN TICK_MODULUS
451 %right TICK_POS TICK_RANGE TICK_SIZE TICK_TAG TICK_VAL
452 /* The following are right-associative only so that reductions at this
453 precedence have lower precedence than '.' and '('. The syntax still
454 forces a.b.c, e.g., to be LEFT-associated. */
455 %right '.' '(' '[' DOT_ID DOT_ALL
465 /* Expressions, including the sequencing operator. */
468 { ada_wrap2<comma_operation> (BINOP_COMMA); }
469 | primary ASSIGN exp /* Extension for convenience */
471 operation_up rhs = pstate->pop ();
472 operation_up lhs = ada_pop ();
474 = lhs->evaluate (nullptr, pstate->expout.get (),
475 EVAL_AVOID_SIDE_EFFECTS);
476 rhs = resolve (std::move (rhs), true,
477 value_type (lhs_val));
478 pstate->push_new<ada_assign_operation>
479 (std::move (lhs), std::move (rhs));
483 /* Expressions, not including the sequencing operator. */
484 primary : primary DOT_ALL
485 { ada_wrap<ada_unop_ind_operation> (); }
488 primary : primary DOT_ID
490 operation_up arg = ada_pop ();
491 pstate->push_new<ada_structop_operation>
492 (std::move (arg), copy_name ($2));
496 primary : primary '(' arglist ')'
497 { ada_funcall ($3); }
498 | var_or_type '(' arglist ')'
503 error (_("Invalid conversion"));
504 operation_up arg = ada_pop ();
505 pstate->push_new<unop_cast_operation>
506 (std::move (arg), $1);
513 primary : var_or_type '\'' '(' exp ')'
516 error (_("Type required for qualification"));
517 operation_up arg = ada_pop (true,
519 pstate->push_new<ada_qual_operation>
520 (std::move (arg), $1);
525 primary '(' simple_exp DOTDOT simple_exp ')'
526 { ada_wrap3<ada_ternop_slice_operation> (); }
527 | var_or_type '(' simple_exp DOTDOT simple_exp ')'
529 ada_wrap3<ada_ternop_slice_operation> ();
531 error (_("Cannot slice a type"));
535 primary : '(' exp1 ')' { }
538 /* The following rule causes a conflict with the type conversion
540 To get around it, we give '(' higher priority and add bridge rules for
541 var_or_type (exp, exp, ...)
542 var_or_type (exp .. exp)
543 We also have the action for var_or_type(exp) generate a function call
544 when the first symbol does not denote a type. */
546 primary : var_or_type %prec VAR
548 pstate->push_new<type_operation> ($1);
552 primary : DOLLAR_VARIABLE /* Various GDB extensions */
553 { pstate->push_dollar ($1); }
558 pstate->push_new<ada_aggregate_operation>
566 simple_exp : '-' simple_exp %prec UNARY
567 { ada_wrap_overload<ada_neg_operation> (UNOP_NEG); }
570 simple_exp : '+' simple_exp %prec UNARY
572 operation_up arg = ada_pop ();
575 /* If an overloaded operator was found, use
576 it. Otherwise, unary + has no effect and
577 the argument can be pushed instead. */
578 operation_up call = maybe_overload (UNOP_PLUS, arg,
581 arg = std::move (call);
582 pstate->push (std::move (arg));
586 simple_exp : NOT simple_exp %prec UNARY
588 ada_wrap_overload<unary_logical_not_operation>
593 simple_exp : ABS simple_exp %prec UNARY
594 { ada_wrap_overload<ada_abs_operation> (UNOP_ABS); }
597 arglist : { $$ = 0; }
606 | arglist ',' NAME ARROW exp
610 primary : '{' var_or_type '}' primary %prec '.'
614 error (_("Type required within braces in coercion"));
615 operation_up arg = ada_pop ();
616 pstate->push_new<unop_memval_operation>
617 (std::move (arg), $2);
621 /* Binary operators in order of decreasing precedence. */
623 simple_exp : simple_exp STARSTAR simple_exp
624 { ada_wrap2<ada_binop_exp_operation> (BINOP_EXP); }
627 simple_exp : simple_exp '*' simple_exp
628 { ada_wrap2<ada_binop_mul_operation> (BINOP_MUL); }
631 simple_exp : simple_exp '/' simple_exp
632 { ada_wrap2<ada_binop_div_operation> (BINOP_DIV); }
635 simple_exp : simple_exp REM simple_exp /* May need to be fixed to give correct Ada REM */
636 { ada_wrap2<ada_binop_rem_operation> (BINOP_REM); }
639 simple_exp : simple_exp MOD simple_exp
640 { ada_wrap2<ada_binop_mod_operation> (BINOP_MOD); }
643 simple_exp : simple_exp '@' simple_exp /* GDB extension */
644 { ada_wrap2<repeat_operation> (BINOP_REPEAT); }
647 simple_exp : simple_exp '+' simple_exp
648 { ada_wrap_op<ada_binop_addsub_operation> (BINOP_ADD); }
651 simple_exp : simple_exp '&' simple_exp
652 { ada_wrap2<concat_operation> (BINOP_CONCAT); }
655 simple_exp : simple_exp '-' simple_exp
656 { ada_wrap_op<ada_binop_addsub_operation> (BINOP_SUB); }
659 relation : simple_exp
662 relation : simple_exp '=' simple_exp
663 { ada_wrap_op<ada_binop_equal_operation> (BINOP_EQUAL); }
666 relation : simple_exp NOTEQUAL simple_exp
667 { ada_wrap_op<ada_binop_equal_operation> (BINOP_NOTEQUAL); }
670 relation : simple_exp LEQ simple_exp
671 { ada_un_wrap2<leq_operation> (BINOP_LEQ); }
674 relation : simple_exp IN simple_exp DOTDOT simple_exp
675 { ada_wrap3<ada_ternop_range_operation> (); }
676 | simple_exp IN primary TICK_RANGE tick_arglist
678 operation_up rhs = ada_pop ();
679 operation_up lhs = ada_pop ();
680 pstate->push_new<ada_binop_in_bounds_operation>
681 (std::move (lhs), std::move (rhs), $5);
683 | simple_exp IN var_or_type %prec TICK_ACCESS
686 error (_("Right operand of 'in' must be type"));
687 operation_up arg = ada_pop ();
688 pstate->push_new<ada_unop_range_operation>
689 (std::move (arg), $3);
691 | simple_exp NOT IN simple_exp DOTDOT simple_exp
692 { ada_wrap3<ada_ternop_range_operation> ();
693 ada_wrap<unary_logical_not_operation> (); }
694 | simple_exp NOT IN primary TICK_RANGE tick_arglist
696 operation_up rhs = ada_pop ();
697 operation_up lhs = ada_pop ();
698 pstate->push_new<ada_binop_in_bounds_operation>
699 (std::move (lhs), std::move (rhs), $6);
700 ada_wrap<unary_logical_not_operation> ();
702 | simple_exp NOT IN var_or_type %prec TICK_ACCESS
705 error (_("Right operand of 'in' must be type"));
706 operation_up arg = ada_pop ();
707 pstate->push_new<ada_unop_range_operation>
708 (std::move (arg), $4);
709 ada_wrap<unary_logical_not_operation> ();
713 relation : simple_exp GEQ simple_exp
714 { ada_un_wrap2<geq_operation> (BINOP_GEQ); }
717 relation : simple_exp '<' simple_exp
718 { ada_un_wrap2<less_operation> (BINOP_LESS); }
721 relation : simple_exp '>' simple_exp
722 { ada_un_wrap2<gtr_operation> (BINOP_GTR); }
734 relation _AND_ relation
735 { ada_wrap2<ada_bitwise_and_operation>
736 (BINOP_BITWISE_AND); }
737 | and_exp _AND_ relation
738 { ada_wrap2<ada_bitwise_and_operation>
739 (BINOP_BITWISE_AND); }
743 relation _AND_ THEN relation
744 { ada_wrap2<logical_and_operation>
745 (BINOP_LOGICAL_AND); }
746 | and_then_exp _AND_ THEN relation
747 { ada_wrap2<logical_and_operation>
748 (BINOP_LOGICAL_AND); }
753 { ada_wrap2<ada_bitwise_ior_operation>
754 (BINOP_BITWISE_IOR); }
756 { ada_wrap2<ada_bitwise_ior_operation>
757 (BINOP_BITWISE_IOR); }
761 relation OR ELSE relation
762 { ada_wrap2<logical_or_operation> (BINOP_LOGICAL_OR); }
763 | or_else_exp OR ELSE relation
764 { ada_wrap2<logical_or_operation> (BINOP_LOGICAL_OR); }
767 xor_exp : relation XOR relation
768 { ada_wrap2<ada_bitwise_xor_operation>
769 (BINOP_BITWISE_XOR); }
770 | xor_exp XOR relation
771 { ada_wrap2<ada_bitwise_xor_operation>
772 (BINOP_BITWISE_XOR); }
775 /* Primaries can denote types (OP_TYPE). In cases such as
776 primary TICK_ADDRESS, where a type would be invalid, it will be
777 caught when evaluate_subexp in ada-lang.c tries to evaluate the
778 primary, expecting a value. Precedence rules resolve the ambiguity
779 in NAME TICK_ACCESS in favor of shifting to form a var_or_type. A
780 construct such as aType'access'access will again cause an error when
781 aType'access evaluates to a type that evaluate_subexp attempts to
783 primary : primary TICK_ACCESS
785 | primary TICK_ADDRESS
786 { ada_addrof (type_system_address (pstate)); }
787 | primary TICK_FIRST tick_arglist
789 operation_up arg = ada_pop ();
790 pstate->push_new<ada_unop_atr_operation>
791 (std::move (arg), OP_ATR_FIRST, $3);
793 | primary TICK_LAST tick_arglist
795 operation_up arg = ada_pop ();
796 pstate->push_new<ada_unop_atr_operation>
797 (std::move (arg), OP_ATR_LAST, $3);
799 | primary TICK_LENGTH tick_arglist
801 operation_up arg = ada_pop ();
802 pstate->push_new<ada_unop_atr_operation>
803 (std::move (arg), OP_ATR_LENGTH, $3);
806 { ada_wrap<ada_atr_size_operation> (); }
808 { ada_wrap<ada_atr_tag_operation> (); }
809 | opt_type_prefix TICK_MIN '(' exp ',' exp ')'
810 { ada_wrap2<ada_binop_min_operation> (BINOP_MIN); }
811 | opt_type_prefix TICK_MAX '(' exp ',' exp ')'
812 { ada_wrap2<ada_binop_max_operation> (BINOP_MAX); }
813 | opt_type_prefix TICK_POS '(' exp ')'
814 { ada_wrap<ada_pos_operation> (); }
815 | type_prefix TICK_VAL '(' exp ')'
817 operation_up arg = ada_pop ();
818 pstate->push_new<ada_atr_val_operation>
819 ($1, std::move (arg));
821 | type_prefix TICK_MODULUS
823 struct type *type_arg = check_typedef ($1);
824 if (!ada_is_modular_type (type_arg))
825 error (_("'modulus must be applied to modular type"));
826 write_int (pstate, ada_modulus (type_arg),
827 TYPE_TARGET_TYPE (type_arg));
831 tick_arglist : %prec '('
841 error (_("Prefix must be type"));
850 { $$ = parse_type (pstate)->builtin_void; }
855 { write_int (pstate, (LONGEST) $1.val, $1.type); }
860 pstate->push_new<ada_char_operation> ($1.type, $1.val);
867 std::copy (std::begin ($1.val), std::end ($1.val),
869 pstate->push_new<float_const_operation>
871 ada_wrap<ada_wrapped_operation> ();
877 struct type *null_ptr_type
878 = lookup_pointer_type (parse_type (pstate)->builtin_int0);
879 write_int (pstate, 0, null_ptr_type);
885 pstate->push_new<ada_string_operation>
890 primary : TRUEKEYWORD
891 { write_int (pstate, 1, type_boolean (pstate)); }
893 { write_int (pstate, 0, type_boolean (pstate)); }
897 { error (_("NEW not implemented.")); }
900 var_or_type: NAME %prec VAR
901 { $$ = write_var_or_type (pstate, NULL, $1); }
902 | block NAME %prec VAR
903 { $$ = write_var_or_type (pstate, $1, $2); }
906 $$ = write_var_or_type (pstate, NULL, $1);
910 $$ = lookup_pointer_type ($$);
912 | block NAME TICK_ACCESS
914 $$ = write_var_or_type (pstate, $1, $2);
918 $$ = lookup_pointer_type ($$);
923 block : NAME COLONCOLON
924 { $$ = block_lookup (NULL, $1.ptr); }
925 | block NAME COLONCOLON
926 { $$ = block_lookup ($1, $2.ptr); }
930 '(' aggregate_component_list ')'
932 std::vector<ada_component_up> components
933 = pop_components ($2);
935 push_component<ada_aggregate_component>
936 (std::move (components));
940 aggregate_component_list :
941 component_groups { $$ = $1; }
942 | positional_list exp
944 push_component<ada_positional_component>
948 | positional_list component_groups
955 push_component<ada_positional_component>
959 | positional_list exp ','
961 push_component<ada_positional_component>
969 | component_group { $$ = 1; }
970 | component_group ',' component_groups
974 others : OTHERS ARROW exp
976 push_component<ada_others_component> (ada_pop ());
981 component_associations
983 ada_choices_component *choices = choice_component ();
984 choices->set_associations (pop_associations ($1));
988 /* We use this somewhat obscure definition in order to handle NAME => and
989 NAME | differently from exp => and exp |. ARROW and '|' have a precedence
990 above that of the reduction of NAME to var_or_type. By delaying
991 decisions until after the => or '|', we convert the ambiguity to a
992 resolved shift/reduce conflict. */
993 component_associations :
996 push_component<ada_choices_component> (ada_pop ());
997 write_name_assoc (pstate, $1);
1000 | simple_exp ARROW exp
1002 push_component<ada_choices_component> (ada_pop ());
1003 push_association<ada_name_association> (ada_pop ());
1006 | simple_exp DOTDOT simple_exp ARROW exp
1008 push_component<ada_choices_component> (ada_pop ());
1009 operation_up rhs = ada_pop ();
1010 operation_up lhs = ada_pop ();
1011 push_association<ada_discrete_range_association>
1012 (std::move (lhs), std::move (rhs));
1015 | NAME '|' component_associations
1017 write_name_assoc (pstate, $1);
1020 | simple_exp '|' component_associations
1022 push_association<ada_name_association> (ada_pop ());
1025 | simple_exp DOTDOT simple_exp '|' component_associations
1028 operation_up rhs = ada_pop ();
1029 operation_up lhs = ada_pop ();
1030 push_association<ada_discrete_range_association>
1031 (std::move (lhs), std::move (rhs));
1036 /* Some extensions borrowed from C, for the benefit of those who find they
1037 can't get used to Ada notation in GDB. */
1039 primary : '*' primary %prec '.'
1040 { ada_wrap<ada_unop_ind_operation> (); }
1041 | '&' primary %prec '.'
1043 | primary '[' exp ']'
1045 ada_wrap2<subscript_operation> (BINOP_SUBSCRIPT);
1046 ada_wrap<ada_wrapped_operation> ();
1052 /* yylex defined in ada-lex.c: Reads one token, getting characters */
1053 /* through lexptr. */
1055 /* Remap normal flex interface names (yylex) as well as gratuitiously */
1056 /* global symbol names, so we can have multiple flex-generated parsers */
1059 /* (See note above on previous definitions for YACC.) */
1061 #define yy_create_buffer ada_yy_create_buffer
1062 #define yy_delete_buffer ada_yy_delete_buffer
1063 #define yy_init_buffer ada_yy_init_buffer
1064 #define yy_load_buffer_state ada_yy_load_buffer_state
1065 #define yy_switch_to_buffer ada_yy_switch_to_buffer
1066 #define yyrestart ada_yyrestart
1067 #define yytext ada_yytext
1069 static struct obstack temp_parse_space;
1071 /* The following kludge was found necessary to prevent conflicts between */
1072 /* defs.h and non-standard stdlib.h files. */
1073 #define qsort __qsort__dummy
1074 #include "ada-lex.c"
1077 ada_parse (struct parser_state *par_state)
1079 /* Setting up the parser state. */
1080 scoped_restore pstate_restore = make_scoped_restore (&pstate);
1081 gdb_assert (par_state != NULL);
1084 lexer_init (yyin); /* (Re-)initialize lexer. */
1085 obstack_free (&temp_parse_space, NULL);
1086 obstack_init (&temp_parse_space);
1087 components.clear ();
1088 associations.clear ();
1090 int result = yyparse ();
1093 struct type *context_type = nullptr;
1094 if (par_state->void_context_p)
1095 context_type = parse_type (par_state)->builtin_void;
1096 pstate->set_operation (ada_pop (true, context_type));
1102 yyerror (const char *msg)
1104 error (_("Error in expression, near `%s'."), pstate->lexptr);
1107 /* Emit expression to access an instance of SYM, in block BLOCK (if
1111 write_var_from_sym (struct parser_state *par_state, block_symbol sym)
1113 if (symbol_read_needs_frame (sym.symbol))
1114 par_state->block_tracker->update (sym.block, INNERMOST_BLOCK_FOR_SYMBOLS);
1116 par_state->push_new<ada_var_value_operation> (sym);
1119 /* Write integer or boolean constant ARG of type TYPE. */
1122 write_int (struct parser_state *par_state, LONGEST arg, struct type *type)
1124 pstate->push_new<long_const_operation> (type, arg);
1125 ada_wrap<ada_wrapped_operation> ();
1128 /* Emit expression corresponding to the renamed object named
1129 * designated by RENAMED_ENTITY[0 .. RENAMED_ENTITY_LEN-1] in the
1130 * context of ORIG_LEFT_CONTEXT, to which is applied the operations
1131 * encoded by RENAMING_EXPR. MAX_DEPTH is the maximum number of
1132 * cascaded renamings to allow. If ORIG_LEFT_CONTEXT is null, it
1133 * defaults to the currently selected block. ORIG_SYMBOL is the
1134 * symbol that originally encoded the renaming. It is needed only
1135 * because its prefix also qualifies any index variables used to index
1136 * or slice an array. It should not be necessary once we go to the
1137 * new encoding entirely (FIXME pnh 7/20/2007). */
1140 write_object_renaming (struct parser_state *par_state,
1141 const struct block *orig_left_context,
1142 const char *renamed_entity, int renamed_entity_len,
1143 const char *renaming_expr, int max_depth)
1146 enum { SIMPLE_INDEX, LOWER_BOUND, UPPER_BOUND } slice_state;
1147 struct block_symbol sym_info;
1150 error (_("Could not find renamed symbol"));
1152 if (orig_left_context == NULL)
1153 orig_left_context = get_selected_block (NULL);
1155 name = obstack_strndup (&temp_parse_space, renamed_entity,
1156 renamed_entity_len);
1157 ada_lookup_encoded_symbol (name, orig_left_context, VAR_DOMAIN, &sym_info);
1158 if (sym_info.symbol == NULL)
1159 error (_("Could not find renamed variable: %s"), ada_decode (name).c_str ());
1160 else if (SYMBOL_CLASS (sym_info.symbol) == LOC_TYPEDEF)
1161 /* We have a renaming of an old-style renaming symbol. Don't
1162 trust the block information. */
1163 sym_info.block = orig_left_context;
1166 const char *inner_renamed_entity;
1167 int inner_renamed_entity_len;
1168 const char *inner_renaming_expr;
1170 switch (ada_parse_renaming (sym_info.symbol, &inner_renamed_entity,
1171 &inner_renamed_entity_len,
1172 &inner_renaming_expr))
1174 case ADA_NOT_RENAMING:
1175 write_var_from_sym (par_state, sym_info);
1177 case ADA_OBJECT_RENAMING:
1178 write_object_renaming (par_state, sym_info.block,
1179 inner_renamed_entity, inner_renamed_entity_len,
1180 inner_renaming_expr, max_depth - 1);
1187 slice_state = SIMPLE_INDEX;
1188 while (*renaming_expr == 'X')
1192 switch (*renaming_expr) {
1195 ada_wrap<ada_unop_ind_operation> ();
1198 slice_state = LOWER_BOUND;
1202 if (isdigit (*renaming_expr))
1205 long val = strtol (renaming_expr, &next, 10);
1206 if (next == renaming_expr)
1208 renaming_expr = next;
1209 write_int (par_state, val, type_int (par_state));
1215 struct block_symbol index_sym_info;
1217 end = strchr (renaming_expr, 'X');
1219 end = renaming_expr + strlen (renaming_expr);
1221 index_name = obstack_strndup (&temp_parse_space, renaming_expr,
1222 end - renaming_expr);
1223 renaming_expr = end;
1225 ada_lookup_encoded_symbol (index_name, orig_left_context,
1226 VAR_DOMAIN, &index_sym_info);
1227 if (index_sym_info.symbol == NULL)
1228 error (_("Could not find %s"), index_name);
1229 else if (SYMBOL_CLASS (index_sym_info.symbol) == LOC_TYPEDEF)
1230 /* Index is an old-style renaming symbol. */
1231 index_sym_info.block = orig_left_context;
1232 write_var_from_sym (par_state, index_sym_info);
1234 if (slice_state == SIMPLE_INDEX)
1236 else if (slice_state == LOWER_BOUND)
1237 slice_state = UPPER_BOUND;
1238 else if (slice_state == UPPER_BOUND)
1240 ada_wrap3<ada_ternop_slice_operation> ();
1241 slice_state = SIMPLE_INDEX;
1251 if (slice_state != SIMPLE_INDEX)
1253 end = strchr (renaming_expr, 'X');
1255 end = renaming_expr + strlen (renaming_expr);
1257 operation_up arg = ada_pop ();
1258 pstate->push_new<ada_structop_operation>
1259 (std::move (arg), std::string (renaming_expr,
1260 end - renaming_expr));
1261 renaming_expr = end;
1269 if (slice_state == SIMPLE_INDEX)
1273 error (_("Internal error in encoding of renaming declaration"));
1276 static const struct block*
1277 block_lookup (const struct block *context, const char *raw_name)
1280 struct symtab *symtab;
1281 const struct block *result = NULL;
1283 std::string name_storage;
1284 if (raw_name[0] == '\'')
1291 name_storage = ada_encode (raw_name);
1292 name = name_storage.c_str ();
1295 std::vector<struct block_symbol> syms
1296 = ada_lookup_symbol_list (name, context, VAR_DOMAIN);
1299 && (syms.empty () || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK))
1300 symtab = lookup_symtab (name);
1305 result = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symtab), STATIC_BLOCK);
1306 else if (syms.empty () || SYMBOL_CLASS (syms[0].symbol) != LOC_BLOCK)
1308 if (context == NULL)
1309 error (_("No file or function \"%s\"."), raw_name);
1311 error (_("No function \"%s\" in specified context."), raw_name);
1315 if (syms.size () > 1)
1316 warning (_("Function name \"%s\" ambiguous here"), raw_name);
1317 result = SYMBOL_BLOCK_VALUE (syms[0].symbol);
1323 static struct symbol*
1324 select_possible_type_sym (const std::vector<struct block_symbol> &syms)
1327 int preferred_index;
1328 struct type *preferred_type;
1330 preferred_index = -1; preferred_type = NULL;
1331 for (i = 0; i < syms.size (); i += 1)
1332 switch (SYMBOL_CLASS (syms[i].symbol))
1335 if (ada_prefer_type (SYMBOL_TYPE (syms[i].symbol), preferred_type))
1337 preferred_index = i;
1338 preferred_type = SYMBOL_TYPE (syms[i].symbol);
1344 case LOC_REGPARM_ADDR:
1351 if (preferred_type == NULL)
1353 return syms[preferred_index].symbol;
1357 find_primitive_type (struct parser_state *par_state, const char *name)
1360 type = language_lookup_primitive_type (par_state->language (),
1361 par_state->gdbarch (),
1363 if (type == NULL && strcmp ("system__address", name) == 0)
1364 type = type_system_address (par_state);
1368 /* Check to see if we have a regular definition of this
1369 type that just didn't happen to have been read yet. */
1371 char *expanded_name =
1372 (char *) alloca (strlen (name) + sizeof ("standard__"));
1373 strcpy (expanded_name, "standard__");
1374 strcat (expanded_name, name);
1375 sym = ada_lookup_symbol (expanded_name, NULL, VAR_DOMAIN).symbol;
1376 if (sym != NULL && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1377 type = SYMBOL_TYPE (sym);
1384 chop_selector (const char *name, int end)
1387 for (i = end - 1; i > 0; i -= 1)
1388 if (name[i] == '.' || (name[i] == '_' && name[i+1] == '_'))
1393 /* If NAME is a string beginning with a separator (either '__', or
1394 '.'), chop this separator and return the result; else, return
1398 chop_separator (const char *name)
1403 if (name[0] == '_' && name[1] == '_')
1409 /* Given that SELS is a string of the form (<sep><identifier>)*, where
1410 <sep> is '__' or '.', write the indicated sequence of
1411 STRUCTOP_STRUCT expression operators. */
1413 write_selectors (struct parser_state *par_state, const char *sels)
1415 while (*sels != '\0')
1417 const char *p = chop_separator (sels);
1419 while (*sels != '\0' && *sels != '.'
1420 && (sels[0] != '_' || sels[1] != '_'))
1422 operation_up arg = ada_pop ();
1423 pstate->push_new<ada_structop_operation>
1424 (std::move (arg), std::string (p, sels - p));
1428 /* Write a variable access (OP_VAR_VALUE) to ambiguous encoded name
1429 NAME[0..LEN-1], in block context BLOCK, to be resolved later. Writes
1430 a temporary symbol that is valid until the next call to ada_parse.
1433 write_ambiguous_var (struct parser_state *par_state,
1434 const struct block *block, const char *name, int len)
1436 struct symbol *sym = new (&temp_parse_space) symbol ();
1438 SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN;
1439 sym->set_linkage_name (obstack_strndup (&temp_parse_space, name, len));
1440 sym->set_language (language_ada, nullptr);
1442 block_symbol bsym { sym, block };
1443 par_state->push_new<ada_var_value_operation> (bsym);
1446 /* A convenient wrapper around ada_get_field_index that takes
1447 a non NUL-terminated FIELD_NAME0 and a FIELD_NAME_LEN instead
1448 of a NUL-terminated field name. */
1451 ada_nget_field_index (const struct type *type, const char *field_name0,
1452 int field_name_len, int maybe_missing)
1454 char *field_name = (char *) alloca ((field_name_len + 1) * sizeof (char));
1456 strncpy (field_name, field_name0, field_name_len);
1457 field_name[field_name_len] = '\0';
1458 return ada_get_field_index (type, field_name, maybe_missing);
1461 /* If encoded_field_name is the name of a field inside symbol SYM,
1462 then return the type of that field. Otherwise, return NULL.
1464 This function is actually recursive, so if ENCODED_FIELD_NAME
1465 doesn't match one of the fields of our symbol, then try to see
1466 if ENCODED_FIELD_NAME could not be a succession of field names
1467 (in other words, the user entered an expression of the form
1468 TYPE_NAME.FIELD1.FIELD2.FIELD3), in which case we evaluate
1469 each field name sequentially to obtain the desired field type.
1470 In case of failure, we return NULL. */
1472 static struct type *
1473 get_symbol_field_type (struct symbol *sym, const char *encoded_field_name)
1475 const char *field_name = encoded_field_name;
1476 const char *subfield_name;
1477 struct type *type = SYMBOL_TYPE (sym);
1480 if (type == NULL || field_name == NULL)
1482 type = check_typedef (type);
1484 while (field_name[0] != '\0')
1486 field_name = chop_separator (field_name);
1488 fieldno = ada_get_field_index (type, field_name, 1);
1490 return type->field (fieldno).type ();
1492 subfield_name = field_name;
1493 while (*subfield_name != '\0' && *subfield_name != '.'
1494 && (subfield_name[0] != '_' || subfield_name[1] != '_'))
1497 if (subfield_name[0] == '\0')
1500 fieldno = ada_nget_field_index (type, field_name,
1501 subfield_name - field_name, 1);
1505 type = type->field (fieldno).type ();
1506 field_name = subfield_name;
1512 /* Look up NAME0 (an unencoded identifier or dotted name) in BLOCK (or
1513 expression_block_context if NULL). If it denotes a type, return
1514 that type. Otherwise, write expression code to evaluate it as an
1515 object and return NULL. In this second case, NAME0 will, in general,
1516 have the form <name>(.<selector_name>)*, where <name> is an object
1517 or renaming encoded in the debugging data. Calls error if no
1518 prefix <name> matches a name in the debugging data (i.e., matches
1519 either a complete name or, as a wild-card match, the final
1523 write_var_or_type (struct parser_state *par_state,
1524 const struct block *block, struct stoken name0)
1531 block = par_state->expression_context_block;
1533 std::string name_storage = ada_encode (name0.ptr);
1534 name_len = name_storage.size ();
1535 encoded_name = obstack_strndup (&temp_parse_space, name_storage.c_str (),
1537 for (depth = 0; depth < MAX_RENAMING_CHAIN_LENGTH; depth += 1)
1541 tail_index = name_len;
1542 while (tail_index > 0)
1544 struct symbol *type_sym;
1545 struct symbol *renaming_sym;
1546 const char* renaming;
1548 const char* renaming_expr;
1549 int terminator = encoded_name[tail_index];
1551 encoded_name[tail_index] = '\0';
1552 std::vector<struct block_symbol> syms
1553 = ada_lookup_symbol_list (encoded_name, block, VAR_DOMAIN);
1554 encoded_name[tail_index] = terminator;
1556 type_sym = select_possible_type_sym (syms);
1558 if (type_sym != NULL)
1559 renaming_sym = type_sym;
1560 else if (syms.size () == 1)
1561 renaming_sym = syms[0].symbol;
1563 renaming_sym = NULL;
1565 switch (ada_parse_renaming (renaming_sym, &renaming,
1566 &renaming_len, &renaming_expr))
1568 case ADA_NOT_RENAMING:
1570 case ADA_PACKAGE_RENAMING:
1571 case ADA_EXCEPTION_RENAMING:
1572 case ADA_SUBPROGRAM_RENAMING:
1574 int alloc_len = renaming_len + name_len - tail_index + 1;
1576 = (char *) obstack_alloc (&temp_parse_space, alloc_len);
1577 strncpy (new_name, renaming, renaming_len);
1578 strcpy (new_name + renaming_len, encoded_name + tail_index);
1579 encoded_name = new_name;
1580 name_len = renaming_len + name_len - tail_index;
1581 goto TryAfterRenaming;
1583 case ADA_OBJECT_RENAMING:
1584 write_object_renaming (par_state, block, renaming, renaming_len,
1585 renaming_expr, MAX_RENAMING_CHAIN_LENGTH);
1586 write_selectors (par_state, encoded_name + tail_index);
1589 internal_error (__FILE__, __LINE__,
1590 _("impossible value from ada_parse_renaming"));
1593 if (type_sym != NULL)
1595 struct type *field_type;
1597 if (tail_index == name_len)
1598 return SYMBOL_TYPE (type_sym);
1600 /* We have some extraneous characters after the type name.
1601 If this is an expression "TYPE_NAME.FIELD0.[...].FIELDN",
1602 then try to get the type of FIELDN. */
1604 = get_symbol_field_type (type_sym, encoded_name + tail_index);
1605 if (field_type != NULL)
1608 error (_("Invalid attempt to select from type: \"%s\"."),
1611 else if (tail_index == name_len && syms.empty ())
1613 struct type *type = find_primitive_type (par_state,
1620 if (syms.size () == 1)
1622 write_var_from_sym (par_state, syms[0]);
1623 write_selectors (par_state, encoded_name + tail_index);
1626 else if (syms.empty ())
1628 struct bound_minimal_symbol msym
1629 = ada_lookup_simple_minsym (encoded_name);
1630 if (msym.minsym != NULL)
1632 par_state->push_new<ada_var_msym_value_operation> (msym);
1633 /* Maybe cause error here rather than later? FIXME? */
1634 write_selectors (par_state, encoded_name + tail_index);
1638 if (tail_index == name_len
1639 && strncmp (encoded_name, "standard__",
1640 sizeof ("standard__") - 1) == 0)
1641 error (_("No definition of \"%s\" found."), name0.ptr);
1643 tail_index = chop_selector (encoded_name, tail_index);
1647 write_ambiguous_var (par_state, block, encoded_name,
1649 write_selectors (par_state, encoded_name + tail_index);
1654 if (!have_full_symbols () && !have_partial_symbols () && block == NULL)
1655 error (_("No symbol table is loaded. Use the \"file\" command."));
1656 if (block == par_state->expression_context_block)
1657 error (_("No definition of \"%s\" in current context."), name0.ptr);
1659 error (_("No definition of \"%s\" in specified context."), name0.ptr);
1664 error (_("Could not find renamed symbol \"%s\""), name0.ptr);
1668 /* Write a left side of a component association (e.g., NAME in NAME =>
1669 exp). If NAME has the form of a selected component, write it as an
1670 ordinary expression. If it is a simple variable that unambiguously
1671 corresponds to exactly one symbol that does not denote a type or an
1672 object renaming, also write it normally as an OP_VAR_VALUE.
1673 Otherwise, write it as an OP_NAME.
1675 Unfortunately, we don't know at this point whether NAME is supposed
1676 to denote a record component name or the value of an array index.
1677 Therefore, it is not appropriate to disambiguate an ambiguous name
1678 as we normally would, nor to replace a renaming with its referent.
1679 As a result, in the (one hopes) rare case that one writes an
1680 aggregate such as (R => 42) where R renames an object or is an
1681 ambiguous name, one must write instead ((R) => 42). */
1684 write_name_assoc (struct parser_state *par_state, struct stoken name)
1686 if (strchr (name.ptr, '.') == NULL)
1688 std::vector<struct block_symbol> syms
1689 = ada_lookup_symbol_list (name.ptr,
1690 par_state->expression_context_block,
1693 if (syms.size () != 1 || SYMBOL_CLASS (syms[0].symbol) == LOC_TYPEDEF)
1694 pstate->push_new<ada_string_operation> (copy_name (name));
1696 write_var_from_sym (par_state, syms[0]);
1699 if (write_var_or_type (par_state, NULL, name) != NULL)
1700 error (_("Invalid use of type."));
1702 push_association<ada_name_association> (ada_pop ());
1705 static struct type *
1706 type_int (struct parser_state *par_state)
1708 return parse_type (par_state)->builtin_int;
1711 static struct type *
1712 type_long (struct parser_state *par_state)
1714 return parse_type (par_state)->builtin_long;
1717 static struct type *
1718 type_long_long (struct parser_state *par_state)
1720 return parse_type (par_state)->builtin_long_long;
1723 static struct type *
1724 type_long_double (struct parser_state *par_state)
1726 return parse_type (par_state)->builtin_long_double;
1729 static struct type *
1730 type_char (struct parser_state *par_state)
1732 return language_string_char_type (par_state->language (),
1733 par_state->gdbarch ());
1736 static struct type *
1737 type_boolean (struct parser_state *par_state)
1739 return parse_type (par_state)->builtin_bool;
1742 static struct type *
1743 type_system_address (struct parser_state *par_state)
1746 = language_lookup_primitive_type (par_state->language (),
1747 par_state->gdbarch (),
1749 return type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
1752 void _initialize_ada_exp ();
1754 _initialize_ada_exp ()
1756 obstack_init (&temp_parse_space);