1 /* Definitions for Ada expressions
3 Copyright (C) 2020 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 extern struct value
*ada_unop_neg (struct type
*expect_type
,
26 struct expression
*exp
,
27 enum noside noside
, enum exp_opcode op
,
29 extern struct value
*ada_atr_tag (struct type
*expect_type
,
30 struct expression
*exp
,
31 enum noside noside
, enum exp_opcode op
,
33 extern struct value
*ada_atr_size (struct type
*expect_type
,
34 struct expression
*exp
,
35 enum noside noside
, enum exp_opcode op
,
37 extern struct value
*ada_abs (struct type
*expect_type
,
38 struct expression
*exp
,
39 enum noside noside
, enum exp_opcode op
,
41 extern struct value
*ada_unop_in_range (struct type
*expect_type
,
42 struct expression
*exp
,
43 enum noside noside
, enum exp_opcode op
,
44 struct value
*arg1
, struct type
*type
);
45 extern struct value
*ada_mult_binop (struct type
*expect_type
,
46 struct expression
*exp
,
47 enum noside noside
, enum exp_opcode op
,
48 struct value
*arg1
, struct value
*arg2
);
49 extern struct value
*ada_equal_binop (struct type
*expect_type
,
50 struct expression
*exp
,
51 enum noside noside
, enum exp_opcode op
,
52 struct value
*arg1
, struct value
*arg2
);
53 extern struct value
*ada_ternop_slice (struct expression
*exp
,
56 struct value
*low_bound_val
,
57 struct value
*high_bound_val
);
58 extern struct value
*ada_binop_in_bounds (struct expression
*exp
,
63 extern struct value
*ada_binop_minmax (struct type
*expect_type
,
64 struct expression
*exp
,
65 enum noside noside
, enum exp_opcode op
,
68 extern struct value
*ada_pos_atr (struct type
*expect_type
,
69 struct expression
*exp
,
70 enum noside noside
, enum exp_opcode op
,
76 /* In Ada, some generic operations must be wrapped with a handler that
77 handles some Ada-specific type conversions. */
78 class ada_wrapped_operation
79 : public tuple_holding_operation
<operation_up
>
83 using tuple_holding_operation::tuple_holding_operation
;
85 value
*evaluate (struct type
*expect_type
,
86 struct expression
*exp
,
87 enum noside noside
) override
;
89 enum exp_opcode
opcode () const override
90 { return std::get
<0> (m_storage
)->opcode (); }
93 /* An Ada string constant. */
94 class ada_string_operation
95 : public string_operation
99 using string_operation::string_operation
;
101 value
*evaluate (struct type
*expect_type
,
102 struct expression
*exp
,
103 enum noside noside
) override
;
106 /* The Ada TYPE'(EXP) construct. */
107 class ada_qual_operation
108 : public tuple_holding_operation
<operation_up
, struct type
*>
112 using tuple_holding_operation::tuple_holding_operation
;
114 value
*evaluate (struct type
*expect_type
,
115 struct expression
*exp
,
116 enum noside noside
) override
;
118 enum exp_opcode
opcode () const override
119 { return UNOP_QUAL
; }
122 /* Ternary in-range operator. */
123 class ada_ternop_range_operation
124 : public tuple_holding_operation
<operation_up
, operation_up
, operation_up
>
128 using tuple_holding_operation::tuple_holding_operation
;
130 value
*evaluate (struct type
*expect_type
,
131 struct expression
*exp
,
132 enum noside noside
) override
;
134 enum exp_opcode
opcode () const override
135 { return TERNOP_IN_RANGE
; }
138 using ada_neg_operation
= unop_operation
<UNOP_NEG
, ada_unop_neg
>;
139 using ada_atr_tag_operation
= unop_operation
<OP_ATR_TAG
, ada_atr_tag
>;
140 using ada_atr_size_operation
= unop_operation
<OP_ATR_SIZE
, ada_atr_size
>;
141 using ada_abs_operation
= unop_operation
<UNOP_ABS
, ada_abs
>;
142 using ada_pos_operation
= unop_operation
<OP_ATR_POS
, ada_pos_atr
>;
144 /* The in-range operation, given a type. */
145 class ada_unop_range_operation
146 : public tuple_holding_operation
<operation_up
, struct type
*>
150 using tuple_holding_operation::tuple_holding_operation
;
152 value
*evaluate (struct type
*expect_type
,
153 struct expression
*exp
,
154 enum noside noside
) override
156 value
*val
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
157 return ada_unop_in_range (expect_type
, exp
, noside
, UNOP_IN_RANGE
,
158 val
, std::get
<1> (m_storage
));
161 enum exp_opcode
opcode () const override
162 { return UNOP_IN_RANGE
; }
165 /* The Ada + and - operators. */
166 class ada_binop_addsub_operation
167 : public tuple_holding_operation
<enum exp_opcode
, operation_up
, operation_up
>
171 using tuple_holding_operation::tuple_holding_operation
;
173 value
*evaluate (struct type
*expect_type
,
174 struct expression
*exp
,
175 enum noside noside
) override
;
177 enum exp_opcode
opcode () const override
178 { return std::get
<0> (m_storage
); }
181 using ada_binop_mul_operation
= binop_operation
<BINOP_MUL
, ada_mult_binop
>;
182 using ada_binop_div_operation
= binop_operation
<BINOP_DIV
, ada_mult_binop
>;
183 using ada_binop_rem_operation
= binop_operation
<BINOP_REM
, ada_mult_binop
>;
184 using ada_binop_mod_operation
= binop_operation
<BINOP_MOD
, ada_mult_binop
>;
186 using ada_binop_min_operation
= binop_operation
<OP_ATR_MIN
, ada_binop_minmax
>;
187 using ada_binop_max_operation
= binop_operation
<OP_ATR_MAX
, ada_binop_minmax
>;
189 /* Implement the equal and not-equal operations for Ada. */
190 class ada_binop_equal_operation
191 : public tuple_holding_operation
<enum exp_opcode
, operation_up
, operation_up
>
195 using tuple_holding_operation::tuple_holding_operation
;
197 value
*evaluate (struct type
*expect_type
,
198 struct expression
*exp
,
199 enum noside noside
) override
201 value
*arg1
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
202 value
*arg2
= std::get
<2> (m_storage
)->evaluate (value_type (arg1
),
204 return ada_equal_binop (expect_type
, exp
, noside
, std::get
<0> (m_storage
),
208 enum exp_opcode
opcode () const override
209 { return std::get
<0> (m_storage
); }
212 /* Bitwise operators for Ada. */
213 template<enum exp_opcode OP
>
214 class ada_bitwise_operation
215 : public maybe_constant_operation
<operation_up
, operation_up
>
219 using maybe_constant_operation::maybe_constant_operation
;
221 value
*evaluate (struct type
*expect_type
,
222 struct expression
*exp
,
223 enum noside noside
) override
225 value
*lhs
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
226 value
*rhs
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
227 value
*result
= eval_op_binary (expect_type
, exp
, noside
, OP
, lhs
, rhs
);
228 return value_cast (value_type (lhs
), result
);
231 enum exp_opcode
opcode () const override
235 using ada_bitwise_and_operation
= ada_bitwise_operation
<BINOP_BITWISE_AND
>;
236 using ada_bitwise_ior_operation
= ada_bitwise_operation
<BINOP_BITWISE_IOR
>;
237 using ada_bitwise_xor_operation
= ada_bitwise_operation
<BINOP_BITWISE_XOR
>;
239 /* Ada array- or string-slice operation. */
240 class ada_ternop_slice_operation
241 : public maybe_constant_operation
<operation_up
, operation_up
, operation_up
>
245 using maybe_constant_operation::maybe_constant_operation
;
247 value
*evaluate (struct type
*expect_type
,
248 struct expression
*exp
,
249 enum noside noside
) override
251 value
*array
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
252 value
*low
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
253 value
*high
= std::get
<2> (m_storage
)->evaluate (nullptr, exp
, noside
);
254 return ada_ternop_slice (exp
, noside
, array
, low
, high
);
257 enum exp_opcode
opcode () const override
258 { return TERNOP_SLICE
; }
261 /* Implement BINOP_IN_BOUNDS for Ada. */
262 class ada_binop_in_bounds_operation
263 : public maybe_constant_operation
<operation_up
, operation_up
, int>
267 using maybe_constant_operation::maybe_constant_operation
;
269 value
*evaluate (struct type
*expect_type
,
270 struct expression
*exp
,
271 enum noside noside
) override
273 value
*arg1
= std::get
<0> (m_storage
)->evaluate (nullptr, exp
, noside
);
274 value
*arg2
= std::get
<1> (m_storage
)->evaluate (nullptr, exp
, noside
);
275 return ada_binop_in_bounds (exp
, noside
, arg1
, arg2
,
276 std::get
<2> (m_storage
));
279 enum exp_opcode
opcode () const override
280 { return BINOP_IN_BOUNDS
; }
283 /* Implement several unary Ada OP_ATR_* operations. */
284 class ada_unop_atr_operation
285 : public maybe_constant_operation
<operation_up
, enum exp_opcode
, int>
289 using maybe_constant_operation::maybe_constant_operation
;
291 value
*evaluate (struct type
*expect_type
,
292 struct expression
*exp
,
293 enum noside noside
) override
;
295 enum exp_opcode
opcode () const override
296 { return std::get
<1> (m_storage
); }
299 /* Variant of var_value_operation for Ada. */
300 class ada_var_value_operation
301 : public var_value_operation
305 using var_value_operation::var_value_operation
;
307 value
*evaluate (struct type
*expect_type
,
308 struct expression
*exp
,
309 enum noside noside
) override
;
311 value
*evaluate_for_cast (struct type
*expect_type
,
312 struct expression
*exp
,
313 enum noside noside
) override
;
317 using operation::do_generate_ax
;
320 /* Variant of var_msym_value_operation for Ada. */
321 class ada_var_msym_value_operation
322 : public var_msym_value_operation
326 using var_msym_value_operation::var_msym_value_operation
;
328 value
*evaluate_for_cast (struct type
*expect_type
,
329 struct expression
*exp
,
330 enum noside noside
) override
;
334 using operation::do_generate_ax
;
337 } /* namespace expr */
339 #endif /* ADA_EXP_H */