Commit | Line | Data |
---|---|---|
6fab4359 TT |
1 | /* Definitions for Rust 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 RUST_EXP_H | |
21 | #define RUST_EXP_H | |
22 | ||
23 | #include "expop.h" | |
24 | ||
25 | extern struct value *eval_op_rust_complement (struct type *expect_type, | |
26 | struct expression *exp, | |
27 | enum noside noside, | |
28 | enum exp_opcode opcode, | |
29 | struct value *value); | |
30 | extern struct value *eval_op_rust_array (struct type *expect_type, | |
31 | struct expression *exp, | |
32 | enum noside noside, | |
33 | enum exp_opcode opcode, | |
34 | struct value *ncopies, | |
35 | struct value *elt); | |
11dd3dce TT |
36 | extern struct value *eval_op_rust_ind (struct type *expect_type, |
37 | struct expression *exp, | |
38 | enum noside noside, | |
39 | enum exp_opcode opcode, | |
40 | struct value *value); | |
6ce1ad67 TT |
41 | extern struct value *rust_subscript (struct type *expect_type, |
42 | struct expression *exp, | |
43 | enum noside noside, bool for_addr, | |
44 | struct value *lhs, struct value *rhs); | |
9db6b6dd TT |
45 | extern struct value *rust_range (struct type *expect_type, |
46 | struct expression *exp, | |
47 | enum noside noside, enum range_flag kind, | |
48 | struct value *low, struct value *high); | |
e4407a20 TT |
49 | extern struct value *eval_op_rust_struct_anon (struct type *expect_type, |
50 | struct expression *exp, | |
51 | enum noside noside, | |
52 | int field_number, | |
53 | struct value *lhs); | |
54 | extern struct value *eval_op_rust_structop (struct type *expect_type, | |
55 | struct expression *exp, | |
56 | enum noside noside, | |
57 | struct value *lhs, | |
58 | const char *field_name); | |
6fab4359 TT |
59 | |
60 | namespace expr | |
61 | { | |
62 | ||
63 | using rust_unop_compl_operation = unop_operation<UNOP_COMPLEMENT, | |
64 | eval_op_rust_complement>; | |
65 | using rust_array_operation = binop_operation<OP_RUST_ARRAY, | |
66 | eval_op_rust_array>; | |
67 | ||
11dd3dce TT |
68 | /* The Rust indirection operation. */ |
69 | class rust_unop_ind_operation | |
70 | : public unop_ind_operation | |
71 | { | |
72 | public: | |
73 | ||
74 | using unop_ind_operation::unop_ind_operation; | |
75 | ||
76 | value *evaluate (struct type *expect_type, | |
77 | struct expression *exp, | |
78 | enum noside noside) override | |
79 | { | |
80 | if (noside != EVAL_NORMAL) | |
81 | return unop_ind_operation::evaluate (expect_type, exp, noside); | |
82 | ||
83 | value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
84 | return eval_op_rust_ind (expect_type, exp, noside, UNOP_IND, arg1); | |
85 | } | |
86 | }; | |
87 | ||
6ce1ad67 TT |
88 | /* Subscript operator for Rust. */ |
89 | class rust_subscript_operation | |
90 | : public tuple_holding_operation<operation_up, operation_up> | |
91 | { | |
92 | public: | |
93 | ||
94 | using tuple_holding_operation::tuple_holding_operation; | |
95 | ||
96 | value *evaluate (struct type *expect_type, | |
97 | struct expression *exp, | |
98 | enum noside noside) override | |
99 | { | |
100 | value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
101 | value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
102 | return rust_subscript (expect_type, exp, noside, false, arg1, arg2); | |
103 | } | |
104 | ||
105 | value *slice (struct type *expect_type, | |
106 | struct expression *exp, | |
107 | enum noside noside) | |
108 | { | |
109 | value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
110 | value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
111 | return rust_subscript (expect_type, exp, noside, true, arg1, arg2); | |
112 | } | |
113 | ||
114 | enum exp_opcode opcode () const override | |
115 | { return BINOP_SUBSCRIPT; } | |
116 | }; | |
117 | ||
118 | class rust_unop_addr_operation | |
119 | : public tuple_holding_operation<operation_up> | |
120 | { | |
121 | public: | |
122 | ||
123 | using tuple_holding_operation::tuple_holding_operation; | |
124 | ||
125 | value *evaluate (struct type *expect_type, | |
126 | struct expression *exp, | |
127 | enum noside noside) override | |
128 | { | |
129 | operation *oper = std::get<0> (m_storage).get (); | |
130 | rust_subscript_operation *sub_op | |
131 | = dynamic_cast<rust_subscript_operation *> (oper); | |
132 | if (sub_op != nullptr) | |
133 | return sub_op->slice (expect_type, exp, noside); | |
134 | return oper->evaluate_for_address (exp, noside); | |
135 | } | |
136 | ||
137 | enum exp_opcode opcode () const override | |
138 | { return UNOP_ADDR; } | |
139 | }; | |
140 | ||
9db6b6dd TT |
141 | /* The Rust range operators. */ |
142 | class rust_range_operation | |
143 | : public tuple_holding_operation<enum range_flag, operation_up, operation_up> | |
144 | { | |
145 | public: | |
146 | ||
147 | using tuple_holding_operation::tuple_holding_operation; | |
148 | ||
149 | value *evaluate (struct type *expect_type, | |
150 | struct expression *exp, | |
151 | enum noside noside) override | |
152 | { | |
153 | auto kind = std::get<0> (m_storage); | |
154 | value *low = nullptr; | |
155 | if (std::get<1> (m_storage) != nullptr) | |
156 | low = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
157 | value *high = nullptr; | |
158 | if (std::get<2> (m_storage) != nullptr) | |
159 | high = std::get<2> (m_storage)->evaluate (nullptr, exp, noside); | |
160 | return rust_range (expect_type, exp, noside, kind, low, high); | |
161 | } | |
162 | ||
163 | enum exp_opcode opcode () const override | |
164 | { return OP_RANGE; } | |
165 | }; | |
166 | ||
e4407a20 TT |
167 | /* Tuple field reference (using an integer). */ |
168 | class rust_struct_anon | |
169 | : public tuple_holding_operation<int, operation_up> | |
170 | { | |
171 | public: | |
172 | ||
173 | using tuple_holding_operation::tuple_holding_operation; | |
174 | ||
175 | value *evaluate (struct type *expect_type, | |
176 | struct expression *exp, | |
177 | enum noside noside) override | |
178 | { | |
179 | value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); | |
180 | return eval_op_rust_struct_anon (expect_type, exp, noside, | |
181 | std::get<0> (m_storage), lhs); | |
182 | ||
183 | } | |
184 | ||
185 | enum exp_opcode opcode () const override | |
186 | { return STRUCTOP_ANONYMOUS; } | |
187 | }; | |
188 | ||
189 | /* Structure (or union or enum) field reference. */ | |
190 | class rust_structop | |
191 | : public structop_base_operation | |
192 | { | |
193 | public: | |
194 | ||
195 | using structop_base_operation::structop_base_operation; | |
196 | ||
197 | value *evaluate (struct type *expect_type, | |
198 | struct expression *exp, | |
199 | enum noside noside) override | |
200 | { | |
201 | value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
202 | return eval_op_rust_structop (expect_type, exp, noside, lhs, | |
203 | std::get<1> (m_storage).c_str ()); | |
204 | } | |
205 | ||
638fd74a TT |
206 | value *evaluate_funcall (struct type *expect_type, |
207 | struct expression *exp, | |
208 | enum noside noside, | |
209 | const std::vector<operation_up> &args) override; | |
210 | ||
e4407a20 TT |
211 | enum exp_opcode opcode () const override |
212 | { return STRUCTOP_STRUCT; } | |
213 | }; | |
214 | ||
5947d337 TT |
215 | /* Rust aggregate initialization. */ |
216 | class rust_aggregate_operation | |
217 | : public tuple_holding_operation<struct type *, operation_up, | |
218 | std::vector<std::pair<std::string, | |
219 | operation_up>>> | |
220 | { | |
221 | public: | |
222 | ||
223 | using tuple_holding_operation::tuple_holding_operation; | |
224 | ||
225 | value *evaluate (struct type *expect_type, | |
226 | struct expression *exp, | |
227 | enum noside noside) override; | |
228 | ||
229 | enum exp_opcode opcode () const override | |
230 | { return OP_AGGREGATE; } | |
231 | }; | |
232 | ||
6fab4359 TT |
233 | } /* namespace expr */ |
234 | ||
235 | #endif /* RUST_EXP_H */ |