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