Spicy
expression.h
1 // Copyright (c) 2020-2021 by the Zeek Project. See LICENSE for details.
2 
3 #pragma once
4 
5 #include <algorithm>
6 #include <string>
7 #include <utility>
8 #include <vector>
9 
10 #include <hilti/ast/builder/declaration.h>
11 #include <hilti/ast/ctors/all.h>
12 #include <hilti/ast/expressions/all.h>
13 #include <hilti/ast/types/id.h>
14 
15 namespace hilti::builder {
16 
17 // ID expression
18 
19 inline Expression id(ID id_, Meta m = Meta()) { return expression::UnresolvedID(std::move(id_), std::move(m)); }
20 
21 // Ctor expressions
22 
23 inline Expression string(std::string s, const Meta& m = Meta()) {
24  return expression::Ctor(ctor::String(std::move(s), m), m);
25 }
26 
27 inline Expression bool_(bool b, const Meta& m = Meta()) { return expression::Ctor(ctor::Bool(b, m), m); }
28 
29 inline Expression bytes(std::string s, const Meta& m = Meta()) {
30  return expression::Ctor(ctor::Bytes(std::move(s), m), m);
31 }
32 
33 inline Expression coerceTo(Expression e, Type t, const Meta& m) {
34  return expression::PendingCoerced(std::move(e), std::move(t), m);
35 }
36 
37 inline Expression coerceTo(const Expression& e, Type t) {
38  return expression::PendingCoerced(e, std::move(t), e.meta());
39 }
40 
41 inline Expression default_(Type t, const Meta& m = Meta()) {
42  return expression::Ctor(ctor::Default(std::move(t), m), m);
43 }
44 
45 inline Expression default_(Type t, std::vector<Expression> type_args, const Meta& m = Meta()) {
46  return expression::Ctor(ctor::Default(std::move(t), std::move(type_args), m), m);
47 }
48 
49 inline Expression exception(Type t, std::string msg, const Meta& m = Meta()) {
50  return expression::Ctor(ctor::Exception(std::move(t), builder::string(std::move(msg)), m), m);
51 }
52 
53 inline Expression exception(Type t, Expression msg, const Meta& m = Meta()) {
54  return expression::Ctor(ctor::Exception(std::move(t), std::move(msg), m), m);
55 }
56 
57 inline Expression integer(int i, const Meta& m = Meta()) {
58  return expression::Ctor(ctor::SignedInteger(static_cast<int64_t>(i), 64, m), m);
59 }
60 
61 inline Expression integer(int64_t i, const Meta& m = Meta()) {
62  return expression::Ctor(ctor::SignedInteger(i, 64, m), m);
63 }
64 
65 inline Expression integer(unsigned int i, const Meta& m = Meta()) {
66  return expression::Ctor(ctor::UnsignedInteger(i, 64, m), m);
67 }
68 
69 inline Expression integer(uint64_t i, const Meta& m = Meta()) {
70  return expression::Ctor(ctor::UnsignedInteger(i, 64, m), m);
71 }
72 
73 inline Expression null(const Meta& m = Meta()) { return expression::Ctor(ctor::Null(m), m); }
74 
75 inline Expression optional(Expression e, const Meta& m = Meta()) {
76  return expression::Ctor(ctor::Optional(std::move(e), m), m);
77 }
78 
79 inline Expression optional(Type t, const Meta& m = Meta()) {
80  return expression::Ctor(ctor::Optional(std::move(t), m), m);
81 }
82 
83 inline Expression port(hilti::ctor::Port::Value p, const Meta& m = Meta()) {
84  return expression::Ctor(ctor::Port(p, m), m);
85 }
86 
87 inline Expression regexp(std::string p, std::optional<AttributeSet> attrs = {}, const Meta& m = Meta()) {
88  return expression::Ctor(ctor::RegExp({std::move(p)}, std::move(attrs), m), m);
89 }
90 
91 inline Expression regexp(std::vector<std::string> p, std::optional<AttributeSet> attrs = {}, const Meta& m = Meta()) {
92  return expression::Ctor(ctor::RegExp(std::move(p), std::move(attrs), m), m);
93 }
94 
95 inline Expression stream(std::string s, const Meta& m = Meta()) {
96  return expression::Ctor(ctor::Stream(std::move(s), m), m);
97 }
98 
99 inline Expression struct_(std::vector<ctor::struct_::Field> f, const Meta& m = Meta()) {
100  return expression::Ctor(ctor::Struct(std::move(f), m), m);
101 }
102 
103 inline Expression struct_(std::vector<ctor::struct_::Field> f, Type t, const Meta& m = Meta()) {
104  return expression::Ctor(ctor::Struct(std::move(f), std::move(t), m), m);
105 }
106 
107 inline Expression tuple(std::vector<Expression> v, const Meta& m = Meta()) {
108  return expression::Ctor(ctor::Tuple(std::move(v), m), m);
109 }
110 
111 inline Expression vector(const std::vector<Expression>& v, const Meta& m = Meta()) {
112  return expression::Ctor(ctor::Vector(v, m), m);
113 }
114 
115 inline Expression vector(Type t, std::vector<Expression> v, const Meta& m = Meta()) {
116  return expression::Ctor(ctor::Vector(std::move(t), std::move(v), m), m);
117 }
118 
119 inline Expression vector(Type t, const Meta& m = Meta()) {
120  return expression::Ctor(ctor::Vector(std::move(t), {}, m), m);
121 }
122 
123 inline Expression void_(const Meta& m = Meta()) { return expression::Void(m); }
124 
125 inline Expression strong_reference(Type t, const Meta& m = Meta()) {
126  return expression::Ctor(ctor::StrongReference(std::move(t), m), m);
127 }
128 
129 inline Expression weak_reference(Type t, const Meta& m = Meta()) {
130  return expression::Ctor(ctor::WeakReference(std::move(t), m), m);
131 }
132 
133 inline Expression value_reference(Expression e, const Meta& m = Meta()) {
134  return expression::Ctor(ctor::ValueReference(std::move(e), m), m);
135 }
136 
137 // Operator expressions
138 
139 inline Expression and_(Expression op0, Expression op1, const Meta& m = Meta()) {
140  return expression::LogicalAnd(std::move(op0), std::move(op1), m);
141 }
142 
143 inline Expression or_(Expression op0, Expression op1, const Meta& m = Meta()) {
144  return expression::LogicalOr(std::move(op0), std::move(op1), m);
145 }
146 
147 inline Expression begin(Expression e, const Meta& m = Meta()) {
148  return expression::UnresolvedOperator(operator_::Kind::Begin, {std::move(e)}, m);
149 }
150 
151 inline Expression cast(Expression e, Type dst, Meta m = Meta()) {
152  return expression::UnresolvedOperator(operator_::Kind::Cast, {std::move(e), expression::Type_(std::move(dst))},
153  std::move(m));
154 }
155 
156 inline Expression delete_(Expression self, ID field, const Meta& m = Meta()) {
157  return expression::UnresolvedOperator(operator_::Kind::Delete,
158  {std::move(self), expression::Member(std::move(field))}, m);
159 }
160 
161 inline Expression deref(Expression e, const Meta& m = Meta()) {
162  return expression::UnresolvedOperator(operator_::Kind::Deref, {std::move(e)}, m);
163 }
164 
165 inline Expression end(Expression e, const Meta& m = Meta()) {
166  return expression::UnresolvedOperator(operator_::Kind::End, {std::move(e)}, m);
167 }
168 
169 inline Expression call(ID id_, std::vector<Expression> v, const Meta& m = Meta()) {
170  return expression::UnresolvedOperator(operator_::Kind::Call, {id(std::move(id_), m), tuple(std::move(v), m)}, m);
171 }
172 
173 inline Expression index(Expression value, unsigned int index, const Meta& m = Meta()) {
174  return expression::UnresolvedOperator(operator_::Kind::Index, {std::move(value), integer(index, m)}, m);
175 }
176 
177 inline Expression size(Expression op, const Meta& m = Meta()) {
178  return expression::UnresolvedOperator(operator_::Kind::Size, {std::move(op)}, m);
179 }
180 
181 inline Expression modulo(Expression op1, Expression op2, const Meta& m = Meta()) {
182  return expression::UnresolvedOperator(operator_::Kind::Modulo, {std::move(op1), std::move(op2)}, m);
183 }
184 
185 inline Expression lowerEqual(Expression op1, Expression op2, const Meta& m = Meta()) {
186  return expression::UnresolvedOperator(operator_::Kind::LowerEqual, {std::move(op1), std::move(op2)}, m);
187 }
188 
189 inline Expression greaterEqual(Expression op1, Expression op2, const Meta& m = Meta()) {
190  return expression::UnresolvedOperator(operator_::Kind::GreaterEqual, {std::move(op1), std::move(op2)}, m);
191 }
192 
193 inline Expression lower(Expression op1, Expression op2, const Meta& m = Meta()) {
194  return expression::UnresolvedOperator(operator_::Kind::Lower, {std::move(op1), std::move(op2)}, m);
195 }
196 
197 inline Expression greater(Expression op1, Expression op2, const Meta& m = Meta()) {
198  return expression::UnresolvedOperator(operator_::Kind::Greater, {std::move(op1), std::move(op2)}, m);
199 }
200 
201 inline Expression equal(Expression op1, Expression op2, const Meta& m = Meta()) {
202  return expression::UnresolvedOperator(operator_::Kind::Equal, {std::move(op1), std::move(op2)}, m);
203 }
204 
205 inline Expression unequal(Expression op1, Expression op2, const Meta& m = Meta()) {
206  return expression::UnresolvedOperator(operator_::Kind::Unequal, {std::move(op1), std::move(op2)}, m);
207 }
208 
209 inline Expression member(Expression self, std::string id_, const Meta& m = Meta()) {
210  return expression::UnresolvedOperator(operator_::Kind::Member,
211  {std::move(self), expression::Member(ID(std::move(id_)), m)}, m);
212 }
213 
214 inline Expression memberCall(Expression self, std::string id_, std::vector<Expression> v, const Meta& m = Meta()) {
215  return expression::UnresolvedOperator(operator_::Kind::MemberCall,
216  {std::move(self), expression::Member(ID(std::move(id_)), m),
217  tuple(std::move(v), m)},
218  m);
219 }
220 
221 inline Expression unpack(Type type, std::vector<Expression> args, const Meta& m = Meta()) {
222  return expression::UnresolvedOperator(operator_::Kind::Unpack,
223  {hilti::expression::Type_(std::move(type), m), tuple(std::move(args), m)}, m);
224 }
225 
226 inline Expression unset(Expression self, ID field, const Meta& m = Meta()) {
227  return expression::UnresolvedOperator(operator_::Kind::Unset,
228  {std::move(self), expression::Member(std::move(field))}, m);
229 }
230 
231 inline Expression sumAssign(Expression op1, Expression op2, const Meta& m = Meta()) {
232  return expression::UnresolvedOperator(operator_::Kind::SumAssign, {std::move(op1), std::move(op2)}, m);
233 }
234 
235 inline Expression deferred(Expression e, Meta m = Meta()) { return expression::Deferred(std::move(e), std::move(m)); }
236 
237 inline Expression differenceAssign(Expression op1, Expression op2, const Meta& m = Meta()) {
238  return expression::UnresolvedOperator(operator_::Kind::DifferenceAssign, {std::move(op1), std::move(op2)}, m);
239 }
240 
241 inline Expression sum(Expression op1, Expression op2, const Meta& m = Meta()) {
242  return expression::UnresolvedOperator(operator_::Kind::Sum, {std::move(op1), std::move(op2)}, m);
243 }
244 
245 inline Expression difference(Expression op1, Expression op2, const Meta& m = Meta()) {
246  return expression::UnresolvedOperator(operator_::Kind::Difference, {std::move(op1), std::move(op2)}, m);
247 }
248 
249 inline Expression decrementPostfix(Expression op, const Meta& m = Meta()) {
250  return expression::UnresolvedOperator(operator_::Kind::DecrPostfix, {std::move(op)}, m);
251 }
252 
253 inline Expression decrementPrefix(Expression op, const Meta& m = Meta()) {
254  return expression::UnresolvedOperator(operator_::Kind::DecrPrefix, {std::move(op)}, m);
255 }
256 
257 inline Expression incrementPostfix(Expression op, const Meta& m = Meta()) {
258  return expression::UnresolvedOperator(operator_::Kind::IncrPostfix, {std::move(op)}, m);
259 }
260 
261 inline Expression incrementPrefix(Expression op, const Meta& m = Meta()) {
262  return expression::UnresolvedOperator(operator_::Kind::IncrPrefix, {std::move(op)}, m);
263 }
264 
265 inline Expression new_(Type t, const Meta& m = Meta()) {
266  return expression::UnresolvedOperator(operator_::Kind::New,
267  {expression::Type_(std::move(t), m),
269  m);
270 }
271 
272 inline Expression new_(Type t, std::vector<Expression> args, const Meta& m = Meta()) {
273  return expression::UnresolvedOperator(operator_::Kind::New,
274  {expression::Type_(std::move(t), m),
275  hilti::expression::Ctor(hilti::ctor::Tuple(std::move(args), m))},
276  m);
277 }
278 
279 // Other expressions
280 
281 inline Expression expression(Ctor c, Meta m = Meta()) { return expression::Ctor(std::move(c), std::move(m)); }
282 
283 inline Expression expression(const Location& l) { return expression::Ctor(ctor::String(l), l); }
284 
285 inline Expression expression(const Meta& m) { return expression::Ctor(ctor::String(m.location()), m); }
286 
287 inline Expression grouping(Expression e, Meta m = Meta()) { return expression::Grouping(std::move(e), std::move(m)); }
288 
289 inline Expression move(Expression e, Meta m = Meta()) { return expression::Move(std::move(e), std::move(m)); }
290 
291 inline Expression typeinfo(Type t, Meta m = Meta()) {
292  return expression::TypeInfo(expression::Type_(std::move(t), m), m);
293 }
294 
295 inline Expression typeinfo(Expression e, Meta m = Meta()) { return expression::TypeInfo(std::move(e), std::move(m)); }
296 
297 inline Expression self(NodeRef d, Meta m = Meta()) {
298  return expression::Keyword(hilti::expression::keyword::Kind::Self, std::move(d), std::move(m));
299 }
300 
301 inline Expression dollardollar(Meta m = Meta()) {
302  return expression::Keyword(hilti::expression::keyword::Kind::DollarDollar, std::move(m));
303 }
304 
305 inline Expression dollardollar(Type t, Meta m = Meta()) {
306  return expression::Keyword(hilti::expression::keyword::Kind::DollarDollar, std::move(t), std::move(m));
307 }
308 
309 inline Expression assign(Expression target, Expression src, Meta m = Meta()) {
310  return expression::Assign(std::move(target), std::move(src), std::move(m));
311 }
312 
313 inline Expression not_(Expression e, Meta m = Meta()) { return expression::LogicalNot(std::move(e), std::move(m)); }
314 
315 inline Expression ternary(Expression cond, Expression true_, Expression false_, Meta m = Meta()) {
316  return expression::Ternary(std::move(cond), std::move(true_), std::move(false_), std::move(m));
317 }
318 
319 inline Expression min(const Expression& e1, const Expression& e2, const Meta& m = Meta()) {
320  return ternary(lowerEqual(e1, e2, m), e1, e2, m);
321 }
322 
323 inline Expression max(const Expression& e1, const Expression& e2, const Meta& m = Meta()) {
324  return ternary(lowerEqual(e1, e2, m), e2, e1, m);
325 }
326 
327 inline Expression type_wrapped(Expression e, const Meta& m = Meta()) {
328  return expression::TypeWrapped(std::move(e), m);
329 }
330 
331 inline Expression type_wrapped(Expression e, Type t, const Meta& m = Meta()) {
332  return expression::TypeWrapped(std::move(e), std::move(t), m);
333 }
334 
335 inline Expression expect_type(Expression e, Type expected, const Meta& m = Meta()) {
336  return expression::TypeWrapped(e, std::move(expected), expression::TypeWrapped::ValidateTypeMatch(),
337  m ? std::move(m) : e.meta());
338 }
339 
340 // Forces interpreting a given expression as a value of a __library_type.
341 inline Expression library_type_value(Expression e, ID library_type, const Meta& m = Meta()) {
342  return expression::TypeWrapped(e, hilti::type::UnresolvedID(std::move(library_type), m), m);
343 }
344 
345 inline auto port(Expression port, Expression protocol, const Meta& m = Meta()) {
347  "port", "hilti::rt::Port", hilti::type::Port(),
348  hilti::builder::parameters(hilti::builder::parameter(hilti::ID("port"), hilti::type::UnsignedInteger(16)),
349  hilti::builder::parameter(hilti::ID("protocol"),
350  hilti::builder::typeByID("hilti::Protocol"))),
351  std::vector<Expression>{std::move(port), std::move(protocol)}, m);
352 }
353 
354 
355 } // namespace hilti::builder
Definition: type.h:14
Definition: builtin-function.h:16
Definition: port.h:22
Definition: id.h:53
Definition: integer.h:53
Definition: builder.h:20
Definition: ctor.h:14
Definition: id.h:18
Definition: tuple.h:18
Definition: port.h:13