Commit | Line | Data |
---|---|---|
03070ee9 TT |
1 | /* Definitions for Ada expressions |
2 | ||
3 | Copyright (C) 2020 Free Software Foundation, Inc. | |
4 | ||
5 | This file is part of GDB. | |
6 | ||
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. | |
11 | ||
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. | |
16 | ||
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/>. */ | |
19 | ||
20 | #ifndef ADA_EXP_H | |
21 | #define ADA_EXP_H | |
22 | ||
23 | #include "expop.h" | |
24 | ||
7c15d377 TT |
25 | extern struct value *ada_unop_neg (struct type *expect_type, |
26 | struct expression *exp, | |
27 | enum noside noside, enum exp_opcode op, | |
28 | struct value *arg1); | |
29 | extern struct value *ada_atr_tag (struct type *expect_type, | |
30 | struct expression *exp, | |
31 | enum noside noside, enum exp_opcode op, | |
32 | struct value *arg1); | |
33 | extern struct value *ada_atr_size (struct type *expect_type, | |
34 | struct expression *exp, | |
35 | enum noside noside, enum exp_opcode op, | |
36 | struct value *arg1); | |
37 | extern struct value *ada_abs (struct type *expect_type, | |
38 | struct expression *exp, | |
39 | enum noside noside, enum exp_opcode op, | |
40 | struct value *arg1); | |
95d49dfb TT |
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); | |
d9e7db06 TT |
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); | |
6e8fb7b7 TT |
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); | |
1b1ebfab TT |
53 | extern struct value *ada_ternop_slice (struct expression *exp, |
54 | enum noside noside, | |
55 | struct value *array, | |
56 | struct value *low_bound_val, | |
57 | struct value *high_bound_val); | |
82c3886e TT |
58 | extern struct value *ada_binop_in_bounds (struct expression *exp, |
59 | enum noside noside, | |
60 | struct value *arg1, | |
61 | struct value *arg2, | |
62 | int n); | |
7c15d377 | 63 | |
03070ee9 TT |
64 | namespace expr |
65 | { | |
66 | ||
67 | /* In Ada, some generic operations must be wrapped with a handler that | |
68 | handles some Ada-specific type conversions. */ | |
69 | class ada_wrapped_operation | |
70 | : public tuple_holding_operation<operation_up> | |
71 | { | |
72 | public: | |
73 | ||
74 | using tuple_holding_operation::tuple_holding_operation; | |
75 | ||
76 | value *evaluate (struct type *expect_type, | |
77 | struct expression *exp, | |
78 | enum noside noside) override; | |
79 | ||
80 | enum exp_opcode opcode () const override | |
81 | { return std::get<0> (m_storage)->opcode (); } | |
82 | }; | |
83 | ||
42fecb61 TT |
84 | /* An Ada string constant. */ |
85 | class ada_string_operation | |
86 | : public string_operation | |
87 | { | |
88 | public: | |
89 | ||
90 | using string_operation::string_operation; | |
91 | ||
92 | value *evaluate (struct type *expect_type, | |
93 | struct expression *exp, | |
94 | enum noside noside) override; | |
95 | }; | |
96 | ||
cc6bd32e TT |
97 | /* The Ada TYPE'(EXP) construct. */ |
98 | class ada_qual_operation | |
99 | : public tuple_holding_operation<operation_up, struct type *> | |
100 | { | |
101 | public: | |
102 | ||
103 | using tuple_holding_operation::tuple_holding_operation; | |
104 | ||
105 | value *evaluate (struct type *expect_type, | |
106 | struct expression *exp, | |
107 | enum noside noside) override; | |
108 | ||
109 | enum exp_opcode opcode () const override | |
110 | { return UNOP_QUAL; } | |
111 | }; | |
112 | ||
fc715eb2 TT |
113 | /* Ternary in-range operator. */ |
114 | class ada_ternop_range_operation | |
115 | : public tuple_holding_operation<operation_up, operation_up, operation_up> | |
116 | { | |
117 | public: | |
118 | ||
119 | using tuple_holding_operation::tuple_holding_operation; | |
120 | ||
121 | value *evaluate (struct type *expect_type, | |
122 | struct expression *exp, | |
123 | enum noside noside) override; | |
124 | ||
125 | enum exp_opcode opcode () const override | |
126 | { return TERNOP_IN_RANGE; } | |
127 | }; | |
128 | ||
7c15d377 TT |
129 | using ada_neg_operation = unop_operation<UNOP_NEG, ada_unop_neg>; |
130 | using ada_atr_tag_operation = unop_operation<OP_ATR_TAG, ada_atr_tag>; | |
131 | using ada_atr_size_operation = unop_operation<OP_ATR_SIZE, ada_atr_size>; | |
132 | using ada_abs_operation = unop_operation<UNOP_ABS, ada_abs>; | |
133 | ||
95d49dfb TT |
134 | /* The in-range operation, given a type. */ |
135 | class ada_unop_range_operation | |
136 | : public tuple_holding_operation<operation_up, struct type *> | |
137 | { | |
138 | public: | |
139 | ||
140 | using tuple_holding_operation::tuple_holding_operation; | |
141 | ||
142 | value *evaluate (struct type *expect_type, | |
143 | struct expression *exp, | |
144 | enum noside noside) override | |
145 | { | |
146 | value *val = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
147 | return ada_unop_in_range (expect_type, exp, noside, UNOP_IN_RANGE, | |
148 | val, std::get<1> (m_storage)); | |
149 | } | |
150 | ||
151 | enum exp_opcode opcode () const override | |
152 | { return UNOP_IN_RANGE; } | |
153 | }; | |
154 | ||
73796c73 TT |
155 | /* The Ada + and - operators. */ |
156 | class ada_binop_addsub_operation | |
157 | : public tuple_holding_operation<enum exp_opcode, operation_up, operation_up> | |
158 | { | |
159 | public: | |
160 | ||
161 | using tuple_holding_operation::tuple_holding_operation; | |
162 | ||
163 | value *evaluate (struct type *expect_type, | |
164 | struct expression *exp, | |
165 | enum noside noside) override; | |
166 | ||
167 | enum exp_opcode opcode () const override | |
168 | { return std::get<0> (m_storage); } | |
169 | }; | |
170 | ||
d9e7db06 TT |
171 | using ada_binop_mul_operation = binop_operation<BINOP_MUL, ada_mult_binop>; |
172 | using ada_binop_div_operation = binop_operation<BINOP_DIV, ada_mult_binop>; | |
173 | using ada_binop_rem_operation = binop_operation<BINOP_REM, ada_mult_binop>; | |
174 | using ada_binop_mod_operation = binop_operation<BINOP_MOD, ada_mult_binop>; | |
175 | ||
6e8fb7b7 TT |
176 | /* Implement the equal and not-equal operations for Ada. */ |
177 | class ada_binop_equal_operation | |
178 | : public tuple_holding_operation<enum exp_opcode, operation_up, operation_up> | |
179 | { | |
180 | public: | |
181 | ||
182 | using tuple_holding_operation::tuple_holding_operation; | |
183 | ||
184 | value *evaluate (struct type *expect_type, | |
185 | struct expression *exp, | |
186 | enum noside noside) override | |
187 | { | |
188 | value *arg1 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
189 | value *arg2 = std::get<2> (m_storage)->evaluate (value_type (arg1), | |
190 | exp, noside); | |
191 | return ada_equal_binop (expect_type, exp, noside, std::get<0> (m_storage), | |
192 | arg1, arg2); | |
193 | } | |
194 | ||
195 | enum exp_opcode opcode () const override | |
196 | { return std::get<0> (m_storage); } | |
197 | }; | |
198 | ||
039e4b76 TT |
199 | /* Bitwise operators for Ada. */ |
200 | template<enum exp_opcode OP> | |
201 | class ada_bitwise_operation | |
202 | : public maybe_constant_operation<operation_up, operation_up> | |
203 | { | |
204 | public: | |
205 | ||
206 | using maybe_constant_operation::maybe_constant_operation; | |
207 | ||
208 | value *evaluate (struct type *expect_type, | |
209 | struct expression *exp, | |
210 | enum noside noside) override | |
211 | { | |
212 | value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
213 | value *rhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
214 | value *result = eval_op_binary (expect_type, exp, noside, OP, lhs, rhs); | |
215 | return value_cast (value_type (lhs), result); | |
216 | } | |
217 | ||
218 | enum exp_opcode opcode () const override | |
219 | { return OP; } | |
220 | }; | |
221 | ||
222 | using ada_bitwise_and_operation = ada_bitwise_operation<BINOP_BITWISE_AND>; | |
223 | using ada_bitwise_ior_operation = ada_bitwise_operation<BINOP_BITWISE_IOR>; | |
224 | using ada_bitwise_xor_operation = ada_bitwise_operation<BINOP_BITWISE_XOR>; | |
225 | ||
1b1ebfab TT |
226 | /* Ada array- or string-slice operation. */ |
227 | class ada_ternop_slice_operation | |
228 | : public maybe_constant_operation<operation_up, operation_up, operation_up> | |
229 | { | |
230 | public: | |
231 | ||
232 | using maybe_constant_operation::maybe_constant_operation; | |
233 | ||
234 | value *evaluate (struct type *expect_type, | |
235 | struct expression *exp, | |
236 | enum noside noside) override | |
237 | { | |
238 | value *array = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
239 | value *low = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
240 | value *high = std::get<2> (m_storage)->evaluate (nullptr, exp, noside); | |
241 | return ada_ternop_slice (exp, noside, array, low, high); | |
242 | } | |
243 | ||
244 | enum exp_opcode opcode () const override | |
245 | { return TERNOP_SLICE; } | |
246 | }; | |
247 | ||
82c3886e TT |
248 | /* Implement BINOP_IN_BOUNDS for Ada. */ |
249 | class ada_binop_in_bounds_operation | |
250 | : public maybe_constant_operation<operation_up, operation_up, int> | |
251 | { | |
252 | public: | |
253 | ||
254 | using maybe_constant_operation::maybe_constant_operation; | |
255 | ||
256 | value *evaluate (struct type *expect_type, | |
257 | struct expression *exp, | |
258 | enum noside noside) override | |
259 | { | |
260 | value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
261 | value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
262 | return ada_binop_in_bounds (exp, noside, arg1, arg2, | |
263 | std::get<2> (m_storage)); | |
264 | } | |
265 | ||
266 | enum exp_opcode opcode () const override | |
267 | { return BINOP_IN_BOUNDS; } | |
268 | }; | |
269 | ||
03070ee9 TT |
270 | } /* namespace expr */ |
271 | ||
272 | #endif /* ADA_EXP_H */ |