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