CoCalc -- variant

GitHub Repository: godotengine/godot
Path: blob/master/core/variant/variant_op.h
²¹²²³ views
1
/**************************************************************************/
2
/*  variant_op.h                                                          */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
#pragma once
32

33
#include "variant.h"
34

35
#include "core/debugger/engine_debugger.h"
36
#include "core/object/class_db.h"
37

38
template <typename Evaluator>
39
class CommonEvaluate {
40
public:
41
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
42
		VariantTypeChanger<typename Evaluator::ReturnType>::change(r_ret);
43
		Evaluator::validated_evaluate(&p_left, &p_right, r_ret);
44
		r_valid = true;
45
	}
46
	static Variant::Type get_return_type() { return GetTypeInfo<typename Evaluator::ReturnType>::VARIANT_TYPE; }
47
};
48

49
template <typename R, typename A, typename B>
50
class OperatorEvaluatorAdd : public CommonEvaluate<OperatorEvaluatorAdd<R, A, B>> {
51
public:
52
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
53
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) + VariantInternalAccessor<B>::get(right);
54
	}
55
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
56
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
57
	}
58
	using ReturnType = R;
59
};
60

61
template <typename R, typename A, typename B>
62
class OperatorEvaluatorSub : public CommonEvaluate<OperatorEvaluatorSub<R, A, B>> {
63
public:
64
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
65
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) - VariantInternalAccessor<B>::get(right);
66
	}
67
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
68
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
69
	}
70
	using ReturnType = R;
71
};
72

73
template <typename R, typename A, typename B>
74
class OperatorEvaluatorMul : public CommonEvaluate<OperatorEvaluatorMul<R, A, B>> {
75
public:
76
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
77
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) * VariantInternalAccessor<B>::get(right);
78
	}
79
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
80
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
81
	}
82
	using ReturnType = R;
83
};
84

85
template <typename R, typename A, typename B>
86
class OperatorEvaluatorPow : public CommonEvaluate<OperatorEvaluatorPow<R, A, B>> {
87
public:
88
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
89
		VariantInternalAccessor<R>::get(r_ret) = R(Math::pow((double)VariantInternalAccessor<A>::get(left), (double)VariantInternalAccessor<B>::get(right)));
90
	}
91
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
92
		PtrToArg<R>::encode(R(Math::pow((double)PtrToArg<A>::convert(left), (double)PtrToArg<B>::convert(right))), r_ret);
93
	}
94
	using ReturnType = R;
95
};
96

97
template <typename R, typename A, typename B>
98
class OperatorEvaluatorXForm : public CommonEvaluate<OperatorEvaluatorXForm<R, A, B>> {
99
public:
100
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
101
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left).xform(VariantInternalAccessor<B>::get(right));
102
	}
103
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
104
		PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
105
	}
106
	using ReturnType = R;
107
};
108

109
template <typename R, typename A, typename B>
110
class OperatorEvaluatorXFormInv : public CommonEvaluate<OperatorEvaluatorXFormInv<R, A, B>> {
111
public:
112
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
113
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<B>::get(right).xform_inv(VariantInternalAccessor<A>::get(left));
114
	}
115
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
116
		PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
117
	}
118
	using ReturnType = R;
119
};
120

121
template <typename R, typename A, typename B>
122
class OperatorEvaluatorDiv : public CommonEvaluate<OperatorEvaluatorDiv<R, A, B>> {
123
public:
124
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
125
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) / VariantInternalAccessor<B>::get(right);
126
	}
127
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
128
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
129
	}
130
	using ReturnType = R;
131
};
132

133
template <typename R, typename A, typename B>
134
class OperatorEvaluatorDivNZ {
135
public:
136
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
137
		const A &a = VariantInternalAccessor<A>::get(&p_left);
138
		const B &b = VariantInternalAccessor<B>::get(&p_right);
139
		if (b == 0) {
140
			r_valid = false;
141
			*r_ret = "Division by zero error";
142
			return;
143
		}
144
		*r_ret = a / b;
145
		r_valid = true;
146
	}
147
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
148
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) / VariantInternalAccessor<B>::get(right);
149
	}
150
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
151
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
152
	}
153
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
154
};
155

156
template <>
157
class OperatorEvaluatorDivNZ<Vector2i, Vector2i, Vector2i> {
158
public:
159
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
160
		const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
161
		const Vector2i &b = VariantInternalAccessor<Vector2i>::get(&p_right);
162
		if (unlikely(b.x == 0 || b.y == 0)) {
163
			r_valid = false;
164
			*r_ret = "Division by zero error";
165
			return;
166
		}
167
		*r_ret = a / b;
168
		r_valid = true;
169
	}
170
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
171
		VariantTypeChanger<Vector2i>::change(r_ret);
172
		VariantInternalAccessor<Vector2i>::get(r_ret) = VariantInternalAccessor<Vector2i>::get(left) / VariantInternalAccessor<Vector2i>::get(right);
173
	}
174
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
175
		PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) / PtrToArg<Vector2i>::convert(right), r_ret);
176
	}
177
	static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
178
};
179

180
template <>
181
class OperatorEvaluatorDivNZ<Vector3i, Vector3i, Vector3i> {
182
public:
183
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
184
		const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
185
		const Vector3i &b = VariantInternalAccessor<Vector3i>::get(&p_right);
186
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
187
			r_valid = false;
188
			*r_ret = "Division by zero error";
189
			return;
190
		}
191
		*r_ret = a / b;
192
		r_valid = true;
193
	}
194
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
195
		VariantTypeChanger<Vector3i>::change(r_ret);
196
		VariantInternalAccessor<Vector3i>::get(r_ret) = VariantInternalAccessor<Vector3i>::get(left) / VariantInternalAccessor<Vector3i>::get(right);
197
	}
198
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
199
		PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) / PtrToArg<Vector3i>::convert(right), r_ret);
200
	}
201
	static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
202
};
203

204
template <>
205
class OperatorEvaluatorDivNZ<Vector4i, Vector4i, Vector4i> {
206
public:
207
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
208
		const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
209
		const Vector4i &b = VariantInternalAccessor<Vector4i>::get(&p_right);
210
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
211
			r_valid = false;
212
			*r_ret = "Division by zero error";
213
			return;
214
		}
215
		*r_ret = a / b;
216
		r_valid = true;
217
	}
218
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
219
		VariantTypeChanger<Vector4i>::change(r_ret);
220
		VariantInternalAccessor<Vector4i>::get(r_ret) = VariantInternalAccessor<Vector4i>::get(left) / VariantInternalAccessor<Vector4i>::get(right);
221
	}
222
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
223
		PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) / PtrToArg<Vector4i>::convert(right), r_ret);
224
	}
225
	static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
226
};
227

228
template <typename R, typename A, typename B>
229
class OperatorEvaluatorMod : public CommonEvaluate<OperatorEvaluatorMod<R, A, B>> {
230
public:
231
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
232
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) % VariantInternalAccessor<B>::get(right);
233
	}
234
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
235
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
236
	}
237
	using ReturnType = R;
238
};
239

240
template <typename R, typename A, typename B>
241
class OperatorEvaluatorModNZ {
242
public:
243
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
244
		const A &a = VariantInternalAccessor<A>::get(&p_left);
245
		const B &b = VariantInternalAccessor<B>::get(&p_right);
246
		if (b == 0) {
247
			r_valid = false;
248
			*r_ret = "Modulo by zero error";
249
			return;
250
		}
251
		*r_ret = a % b;
252
		r_valid = true;
253
	}
254
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
255
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) % VariantInternalAccessor<B>::get(right);
256
	}
257
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
258
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
259
	}
260
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
261
};
262

263
template <>
264
class OperatorEvaluatorModNZ<Vector2i, Vector2i, Vector2i> {
265
public:
266
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
267
		const Vector2i &a = VariantInternalAccessor<Vector2i>::get(&p_left);
268
		const Vector2i &b = VariantInternalAccessor<Vector2i>::get(&p_right);
269
		if (unlikely(b.x == 0 || b.y == 0)) {
270
			r_valid = false;
271
			*r_ret = "Modulo by zero error";
272
			return;
273
		}
274
		*r_ret = a % b;
275
		r_valid = true;
276
	}
277
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
278
		VariantTypeChanger<Vector2i>::change(r_ret);
279
		VariantInternalAccessor<Vector2i>::get(r_ret) = VariantInternalAccessor<Vector2i>::get(left) % VariantInternalAccessor<Vector2i>::get(right);
280
	}
281
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
282
		PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) % PtrToArg<Vector2i>::convert(right), r_ret);
283
	}
284
	static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
285
};
286

287
template <>
288
class OperatorEvaluatorModNZ<Vector3i, Vector3i, Vector3i> {
289
public:
290
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
291
		const Vector3i &a = VariantInternalAccessor<Vector3i>::get(&p_left);
292
		const Vector3i &b = VariantInternalAccessor<Vector3i>::get(&p_right);
293
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
294
			r_valid = false;
295
			*r_ret = "Modulo by zero error";
296
			return;
297
		}
298
		*r_ret = a % b;
299
		r_valid = true;
300
	}
301
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
302
		VariantTypeChanger<Vector3i>::change(r_ret);
303
		VariantInternalAccessor<Vector3i>::get(r_ret) = VariantInternalAccessor<Vector3i>::get(left) % VariantInternalAccessor<Vector3i>::get(right);
304
	}
305
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
306
		PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) % PtrToArg<Vector3i>::convert(right), r_ret);
307
	}
308
	static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
309
};
310

311
template <>
312
class OperatorEvaluatorModNZ<Vector4i, Vector4i, Vector4i> {
313
public:
314
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
315
		const Vector4i &a = VariantInternalAccessor<Vector4i>::get(&p_left);
316
		const Vector4i &b = VariantInternalAccessor<Vector4i>::get(&p_right);
317
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
318
			r_valid = false;
319
			*r_ret = "Modulo by zero error";
320
			return;
321
		}
322
		*r_ret = a % b;
323
		r_valid = true;
324
	}
325
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
326
		VariantTypeChanger<Vector4i>::change(r_ret);
327
		VariantInternalAccessor<Vector4i>::get(r_ret) = VariantInternalAccessor<Vector4i>::get(left) % VariantInternalAccessor<Vector4i>::get(right);
328
	}
329
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
330
		PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) % PtrToArg<Vector4i>::convert(right), r_ret);
331
	}
332
	static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
333
};
334

335
template <typename R, typename A>
336
class OperatorEvaluatorNeg : public CommonEvaluate<OperatorEvaluatorNeg<R, A>> {
337
public:
338
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
339
		VariantInternalAccessor<R>::get(r_ret) = -VariantInternalAccessor<A>::get(left);
340
	}
341
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
342
		PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
343
	}
344
	using ReturnType = R;
345
};
346

347
template <typename R, typename A>
348
class OperatorEvaluatorPos : public CommonEvaluate<OperatorEvaluatorPos<R, A>> {
349
public:
350
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
351
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left);
352
	}
353
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
354
		PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
355
	}
356
	using ReturnType = R;
357
};
358

359
template <typename R, typename A, typename B>
360
class OperatorEvaluatorShiftLeft {
361
public:
362
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
363
		const A &a = VariantInternalAccessor<A>::get(&p_left);
364
		const B &b = VariantInternalAccessor<B>::get(&p_right);
365

366
#if defined(DEBUG_ENABLED)
367
		if (b < 0 || a < 0) {
368
			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
369
			r_valid = false;
370
			return;
371
		}
372
#endif
373
		*r_ret = a << b;
374
		r_valid = true;
375
	}
376
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
377
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) << VariantInternalAccessor<B>::get(right);
378
	}
379
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
380
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) << PtrToArg<B>::convert(right), r_ret);
381
	}
382
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
383
};
384

385
template <typename R, typename A, typename B>
386
class OperatorEvaluatorShiftRight {
387
public:
388
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
389
		const A &a = VariantInternalAccessor<A>::get(&p_left);
390
		const B &b = VariantInternalAccessor<B>::get(&p_right);
391

392
#if defined(DEBUG_ENABLED)
393
		if (b < 0 || a < 0) {
394
			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
395
			r_valid = false;
396
			return;
397
		}
398
#endif
399
		*r_ret = a >> b;
400
		r_valid = true;
401
	}
402
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
403
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) >> VariantInternalAccessor<B>::get(right);
404
	}
405
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
406
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) >> PtrToArg<B>::convert(right), r_ret);
407
	}
408
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
409
};
410

411
template <typename R, typename A, typename B>
412
class OperatorEvaluatorBitOr : public CommonEvaluate<OperatorEvaluatorBitOr<R, A, B>> {
413
public:
414
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
415
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) | VariantInternalAccessor<B>::get(right);
416
	}
417
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
418
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
419
	}
420
	using ReturnType = R;
421
};
422

423
template <typename R, typename A, typename B>
424
class OperatorEvaluatorBitAnd : public CommonEvaluate<OperatorEvaluatorBitAnd<R, A, B>> {
425
public:
426
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
427
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) & VariantInternalAccessor<B>::get(right);
428
	}
429
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
430
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
431
	}
432
	using ReturnType = R;
433
};
434

435
template <typename R, typename A, typename B>
436
class OperatorEvaluatorBitXor : public CommonEvaluate<OperatorEvaluatorBitXor<R, A, B>> {
437
public:
438
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
439
		VariantInternalAccessor<R>::get(r_ret) = VariantInternalAccessor<A>::get(left) ^ VariantInternalAccessor<B>::get(right);
440
	}
441
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
442
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
443
	}
444
	using ReturnType = R;
445
};
446

447
template <typename R, typename A>
448
class OperatorEvaluatorBitNeg : public CommonEvaluate<OperatorEvaluatorBitNeg<R, A>> {
449
public:
450
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
451
		VariantInternalAccessor<R>::get(r_ret) = ~VariantInternalAccessor<A>::get(left);
452
	}
453
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
454
		PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
455
	}
456
	using ReturnType = R;
457
};
458

459
template <typename A, typename B>
460
class OperatorEvaluatorEqual : public CommonEvaluate<OperatorEvaluatorEqual<A, B>> {
461
public:
462
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
463
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == VariantInternalAccessor<B>::get(right);
464
	}
465
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
466
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
467
	}
468
	using ReturnType = bool;
469
};
470

471
class OperatorEvaluatorEqualObject : public CommonEvaluate<OperatorEvaluatorEqualObject> {
472
public:
473
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
474
		const Object *a = left->get_validated_object();
475
		const Object *b = right->get_validated_object();
476
		VariantInternalAccessor<bool>::get(r_ret) = a == b;
477
	}
478
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
479
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
480
	}
481
	using ReturnType = bool;
482
};
483

484
class OperatorEvaluatorEqualObjectNil : public CommonEvaluate<OperatorEvaluatorEqualObjectNil> {
485
public:
486
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
487
		const Object *a = left->get_validated_object();
488
		VariantInternalAccessor<bool>::get(r_ret) = a == nullptr;
489
	}
490
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
491
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
492
	}
493
	using ReturnType = bool;
494
};
495

496
class OperatorEvaluatorEqualNilObject : public CommonEvaluate<OperatorEvaluatorEqualNilObject> {
497
public:
498
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
499
		const Object *b = right->get_validated_object();
500
		VariantInternalAccessor<bool>::get(r_ret) = nullptr == b;
501
	}
502
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
503
		PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
504
	}
505
	using ReturnType = bool;
506
};
507

508
template <typename A, typename B>
509
class OperatorEvaluatorNotEqual : public CommonEvaluate<OperatorEvaluatorNotEqual<A, B>> {
510
public:
511
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
512
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) != VariantInternalAccessor<B>::get(right);
513
	}
514
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
515
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
516
	}
517
	using ReturnType = bool;
518
};
519

520
class OperatorEvaluatorNotEqualObject : public CommonEvaluate<OperatorEvaluatorNotEqualObject> {
521
public:
522
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
523
		Object *a = left->get_validated_object();
524
		Object *b = right->get_validated_object();
525
		VariantInternalAccessor<bool>::get(r_ret) = a != b;
526
	}
527
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
528
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
529
	}
530
	using ReturnType = bool;
531
};
532

533
class OperatorEvaluatorNotEqualObjectNil : public CommonEvaluate<OperatorEvaluatorNotEqualObjectNil> {
534
public:
535
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
536
		Object *a = left->get_validated_object();
537
		VariantInternalAccessor<bool>::get(r_ret) = a != nullptr;
538
	}
539
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
540
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
541
	}
542
	using ReturnType = bool;
543
};
544

545
class OperatorEvaluatorNotEqualNilObject : public CommonEvaluate<OperatorEvaluatorNotEqualNilObject> {
546
public:
547
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
548
		Object *b = right->get_validated_object();
549
		VariantInternalAccessor<bool>::get(r_ret) = nullptr != b;
550
	}
551
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
552
		PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
553
	}
554
	using ReturnType = bool;
555
};
556

557
template <typename A, typename B>
558
class OperatorEvaluatorLess : public CommonEvaluate<OperatorEvaluatorLess<A, B>> {
559
public:
560
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
561
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) < VariantInternalAccessor<B>::get(right);
562
	}
563
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
564
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
565
	}
566
	using ReturnType = bool;
567
};
568

569
template <typename A, typename B>
570
class OperatorEvaluatorLessEqual : public CommonEvaluate<OperatorEvaluatorLessEqual<A, B>> {
571
public:
572
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
573
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) <= VariantInternalAccessor<B>::get(right);
574
	}
575
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
576
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
577
	}
578
	using ReturnType = bool;
579
};
580

581
template <typename A, typename B>
582
class OperatorEvaluatorGreater : public CommonEvaluate<OperatorEvaluatorGreater<A, B>> {
583
public:
584
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
585
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) > VariantInternalAccessor<B>::get(right);
586
	}
587
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
588
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
589
	}
590
	using ReturnType = bool;
591
};
592

593
template <typename A, typename B>
594
class OperatorEvaluatorGreaterEqual : public CommonEvaluate<OperatorEvaluatorGreaterEqual<A, B>> {
595
public:
596
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
597
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) >= VariantInternalAccessor<B>::get(right);
598
	}
599
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
600
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
601
	}
602
	using ReturnType = bool;
603
};
604

605
template <typename A, typename B>
606
class OperatorEvaluatorAnd : public CommonEvaluate<OperatorEvaluatorAnd<A, B>> {
607
public:
608
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
609
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) && VariantInternalAccessor<B>::get(right);
610
	}
611
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
612
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
613
	}
614
	using ReturnType = bool;
615
};
616

617
template <typename A, typename B>
618
class OperatorEvaluatorOr : public CommonEvaluate<OperatorEvaluatorOr<A, B>> {
619
public:
620
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
621
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) || VariantInternalAccessor<B>::get(right);
622
	}
623
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
624
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
625
	}
626
	using ReturnType = bool;
627
};
628

629
#define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
630
template <typename A, typename B>
631
class OperatorEvaluatorXor : public CommonEvaluate<OperatorEvaluatorXor<A, B>> {
632
public:
633
	_FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
634
		return ((a) || (b)) && !((a) && (b));
635
	}
636
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
637
		VariantInternalAccessor<bool>::get(r_ret) = xor_op(VariantInternalAccessor<A>::get(left), VariantInternalAccessor<B>::get(right));
638
	}
639
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
640
		PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
641
	}
642
	using ReturnType = bool;
643
};
644

645
template <typename A>
646
class OperatorEvaluatorNot : public CommonEvaluate<OperatorEvaluatorNot<A>> {
647
public:
648
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
649
		VariantInternalAccessor<bool>::get(r_ret) = VariantInternalAccessor<A>::get(left) == A();
650
	}
651
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
652
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == A(), r_ret);
653
	}
654
	using ReturnType = bool;
655
};
656

657
//// CUSTOM ////
658

659
class OperatorEvaluatorAddArray : public CommonEvaluate<OperatorEvaluatorAddArray> {
660
public:
661
	_FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
662
		int asize = array_a.size();
663
		int bsize = array_b.size();
664

665
		if (array_a.is_typed() && array_a.is_same_typed(array_b)) {
666
			sum.set_typed(array_a.get_typed_builtin(), array_a.get_typed_class_name(), array_a.get_typed_script());
667
		}
668

669
		sum.resize(asize + bsize);
670
		for (int i = 0; i < asize; i++) {
671
			sum[i] = array_a[i];
672
		}
673
		for (int i = 0; i < bsize; i++) {
674
			sum[i + asize] = array_b[i];
675
		}
676
	}
677
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
678
		*r_ret = Array();
679
		_add_arrays(VariantInternalAccessor<Array>::get(r_ret), VariantInternalAccessor<Array>::get(left), VariantInternalAccessor<Array>::get(right));
680
	}
681
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
682
		Array ret;
683
		_add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
684
		PtrToArg<Array>::encode(ret, r_ret);
685
	}
686
	using ReturnType = Array;
687
};
688

689
template <typename T>
690
class OperatorEvaluatorAppendArray : public CommonEvaluate<OperatorEvaluatorAppendArray<T>> {
691
public:
692
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
693
		VariantInternalAccessor<Vector<T>>::get(r_ret) = VariantInternalAccessor<Vector<T>>::get(left);
694
		VariantInternalAccessor<Vector<T>>::get(r_ret).append_array(VariantInternalAccessor<Vector<T>>::get(right));
695
	}
696
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
697
		Vector<T> sum = PtrToArg<Vector<T>>::convert(left);
698
		sum.append_array(PtrToArg<Vector<T>>::convert(right));
699
		PtrToArg<Vector<T>>::encode(sum, r_ret);
700
	}
701
	using ReturnType = Vector<T>;
702
};
703

704
template <typename Left, typename Right>
705
class OperatorEvaluatorStringConcat : public CommonEvaluate<OperatorEvaluatorStringConcat<Left, Right>> {
706
public:
707
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
708
		const String a(VariantInternalAccessor<Left>::get(left));
709
		const String b(VariantInternalAccessor<Right>::get(right));
710
		VariantInternalAccessor<String>::get(r_ret) = a + b;
711
	}
712
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
713
		const String a(PtrToArg<Left>::convert(left));
714
		const String b(PtrToArg<Right>::convert(right));
715
		PtrToArg<String>::encode(a + b, r_ret);
716
	}
717
	using ReturnType = String;
718
};
719

720
template <typename S, typename T>
721
class OperatorEvaluatorStringFormat;
722

723
template <typename S>
724
class OperatorEvaluatorStringFormat<S, void> {
725
public:
726
	_FORCE_INLINE_ static String do_mod(const String &s, bool *r_valid) {
727
		Array values = { Variant() };
728
		String a = s.sprintf(values, r_valid);
729
		if (r_valid) {
730
			*r_valid = !*r_valid;
731
		}
732
		return a;
733
	}
734
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
735
		*r_ret = do_mod(VariantInternalAccessor<S>::get(&p_left), &r_valid);
736
	}
737
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
738
		bool valid = true;
739
		String result = do_mod(VariantInternalAccessor<S>::get(left), &valid);
740
		if (unlikely(!valid)) {
741
			VariantInternalAccessor<String>::get(r_ret) = VariantInternalAccessor<S>::get(left);
742
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
743
		}
744
		VariantInternalAccessor<String>::get(r_ret) = result;
745
	}
746
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
747
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), nullptr), r_ret);
748
	}
749
	static Variant::Type get_return_type() { return Variant::STRING; }
750
};
751

752
template <typename S>
753
class OperatorEvaluatorStringFormat<S, Array> {
754
public:
755
	_FORCE_INLINE_ static String do_mod(const String &s, const Array &p_values, bool *r_valid) {
756
		String a = s.sprintf(p_values, r_valid);
757
		if (r_valid) {
758
			*r_valid = !*r_valid;
759
		}
760
		return a;
761
	}
762
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
763
		*r_ret = do_mod(VariantInternalAccessor<S>::get(&p_left), VariantInternalAccessor<Array>::get(&p_right), &r_valid);
764
	}
765
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
766
		bool valid = true;
767
		String result = do_mod(VariantInternalAccessor<S>::get(left), VariantInternalAccessor<Array>::get(right), &valid);
768
		if (unlikely(!valid)) {
769
			VariantInternalAccessor<String>::get(r_ret) = VariantInternalAccessor<S>::get(left);
770
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
771
		}
772
		VariantInternalAccessor<String>::get(r_ret) = result;
773
	}
774
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
775
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Array>::convert(right), nullptr), r_ret);
776
	}
777
	static Variant::Type get_return_type() { return Variant::STRING; }
778
};
779

780
template <typename S>
781
class OperatorEvaluatorStringFormat<S, Object> {
782
public:
783
	_FORCE_INLINE_ static String do_mod(const String &s, const Object *p_object, bool *r_valid) {
784
		Array values = { p_object };
785
		String a = s.sprintf(values, r_valid);
786
		if (r_valid) {
787
			*r_valid = !*r_valid;
788
		}
789

790
		return a;
791
	}
792
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
793
		*r_ret = do_mod(VariantInternalAccessor<S>::get(&p_left), p_right.get_validated_object(), &r_valid);
794
	}
795
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
796
		bool valid = true;
797
		String result = do_mod(VariantInternalAccessor<S>::get(left), right->get_validated_object(), &valid);
798
		if (unlikely(!valid)) {
799
			VariantInternalAccessor<String>::get(r_ret) = VariantInternalAccessor<S>::get(left);
800
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
801
		}
802
		VariantInternalAccessor<String>::get(r_ret) = result;
803
	}
804
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
805
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Object *>::convert(right), nullptr), r_ret);
806
	}
807
	static Variant::Type get_return_type() { return Variant::STRING; }
808
};
809

810
template <typename S, typename T>
811
class OperatorEvaluatorStringFormat {
812
public:
813
	_FORCE_INLINE_ static String do_mod(const String &s, const T &p_value, bool *r_valid) {
814
		Array values = { p_value };
815
		String a = s.sprintf(values, r_valid);
816
		if (r_valid) {
817
			*r_valid = !*r_valid;
818
		}
819
		return a;
820
	}
821
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
822
		*r_ret = do_mod(VariantInternalAccessor<S>::get(&p_left), VariantInternalAccessor<T>::get(&p_right), &r_valid);
823
	}
824
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
825
		bool valid = true;
826
		String result = do_mod(VariantInternalAccessor<S>::get(left), VariantInternalAccessor<T>::get(right), &valid);
827
		if (unlikely(!valid)) {
828
			VariantInternalAccessor<String>::get(r_ret) = VariantInternalAccessor<S>::get(left);
829
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
830
		}
831
		VariantInternalAccessor<String>::get(r_ret) = result;
832
	}
833
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
834
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<T>::convert(right), nullptr), r_ret);
835
	}
836
	static Variant::Type get_return_type() { return Variant::STRING; }
837
};
838

839
class OperatorEvaluatorAlwaysTrue : public CommonEvaluate<OperatorEvaluatorAlwaysTrue> {
840
public:
841
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
842
		VariantInternalAccessor<bool>::get(r_ret) = true;
843
	}
844
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
845
		PtrToArg<bool>::encode(true, r_ret);
846
	}
847
	using ReturnType = bool;
848
};
849

850
class OperatorEvaluatorAlwaysFalse : public CommonEvaluate<OperatorEvaluatorAlwaysFalse> {
851
public:
852
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
853
		VariantInternalAccessor<bool>::get(r_ret) = false;
854
	}
855
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
856
		PtrToArg<bool>::encode(false, r_ret);
857
	}
858
	using ReturnType = bool;
859
};
860

861
///// OR ///////
862

863
_FORCE_INLINE_ static bool _operate_or(bool p_left, bool p_right) {
864
	return p_left || p_right;
865
}
866

867
_FORCE_INLINE_ static bool _operate_and(bool p_left, bool p_right) {
868
	return p_left && p_right;
869
}
870

871
_FORCE_INLINE_ static bool _operate_xor(bool p_left, bool p_right) {
872
	return (p_left || p_right) && !(p_left && p_right);
873
}
874

875
_FORCE_INLINE_ static bool _operate_get_nil(const Variant *p_ptr) {
876
	return p_ptr->get_validated_object() != nullptr;
877
}
878

879
_FORCE_INLINE_ static bool _operate_get_bool(const Variant *p_ptr) {
880
	return VariantInternalAccessor<bool>::get(p_ptr);
881
}
882

883
_FORCE_INLINE_ static bool _operate_get_int(const Variant *p_ptr) {
884
	return VariantInternalAccessor<int64_t>::get(p_ptr) != 0;
885
}
886

887
_FORCE_INLINE_ static bool _operate_get_float(const Variant *p_ptr) {
888
	return VariantInternalAccessor<double>::get(p_ptr) != 0.0;
889
}
890

891
_FORCE_INLINE_ static bool _operate_get_object(const Variant *p_ptr) {
892
	return p_ptr->get_validated_object() != nullptr;
893
}
894

895
_FORCE_INLINE_ static bool _operate_get_ptr_nil(const void *p_ptr) {
896
	return false;
897
}
898

899
_FORCE_INLINE_ static bool _operate_get_ptr_bool(const void *p_ptr) {
900
	return PtrToArg<bool>::convert(p_ptr);
901
}
902

903
_FORCE_INLINE_ static bool _operate_get_ptr_int(const void *p_ptr) {
904
	return PtrToArg<int64_t>::convert(p_ptr) != 0;
905
}
906

907
_FORCE_INLINE_ static bool _operate_get_ptr_float(const void *p_ptr) {
908
	return PtrToArg<double>::convert(p_ptr) != 0.0;
909
}
910

911
_FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
912
	return PtrToArg<Object *>::convert(p_ptr) != nullptr;
913
}
914

915
#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op) \
916
	class m_class_name : public CommonEvaluate<m_class_name> { \
917
	public: \
918
		static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) { \
919
			VariantInternalAccessor<bool>::get(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
920
		} \
921
\
922
		static void ptr_evaluate(const void *left, const void *right, void *r_ret) { \
923
			PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret); \
924
		} \
925
\
926
		using ReturnType = bool; \
927
	};
928

929
// OR
930

931
// nil
932
OP_EVALUATOR(OperatorEvaluatorNilXBoolOr, nil, bool, _operate_or)
933
OP_EVALUATOR(OperatorEvaluatorBoolXNilOr, bool, nil, _operate_or)
934

935
OP_EVALUATOR(OperatorEvaluatorNilXIntOr, nil, int, _operate_or)
936
OP_EVALUATOR(OperatorEvaluatorIntXNilOr, int, nil, _operate_or)
937

938
OP_EVALUATOR(OperatorEvaluatorNilXFloatOr, nil, float, _operate_or)
939
OP_EVALUATOR(OperatorEvaluatorFloatXNilOr, float, nil, _operate_or)
940

941
OP_EVALUATOR(OperatorEvaluatorObjectXNilOr, object, nil, _operate_or)
942
OP_EVALUATOR(OperatorEvaluatorNilXObjectOr, nil, object, _operate_or)
943

944
// bool
945
OP_EVALUATOR(OperatorEvaluatorBoolXBoolOr, bool, bool, _operate_or)
946

947
OP_EVALUATOR(OperatorEvaluatorBoolXIntOr, bool, int, _operate_or)
948
OP_EVALUATOR(OperatorEvaluatorIntXBoolOr, int, bool, _operate_or)
949

950
OP_EVALUATOR(OperatorEvaluatorBoolXFloatOr, bool, float, _operate_or)
951
OP_EVALUATOR(OperatorEvaluatorFloatXBoolOr, float, bool, _operate_or)
952

953
OP_EVALUATOR(OperatorEvaluatorBoolXObjectOr, bool, object, _operate_or)
954
OP_EVALUATOR(OperatorEvaluatorObjectXBoolOr, object, bool, _operate_or)
955

956
// int
957
OP_EVALUATOR(OperatorEvaluatorIntXIntOr, int, int, _operate_or)
958

959
OP_EVALUATOR(OperatorEvaluatorIntXFloatOr, int, float, _operate_or)
960
OP_EVALUATOR(OperatorEvaluatorFloatXIntOr, float, int, _operate_or)
961

962
OP_EVALUATOR(OperatorEvaluatorIntXObjectOr, int, object, _operate_or)
963
OP_EVALUATOR(OperatorEvaluatorObjectXIntOr, object, int, _operate_or)
964

965
// float
966
OP_EVALUATOR(OperatorEvaluatorFloatXFloatOr, float, float, _operate_or)
967

968
OP_EVALUATOR(OperatorEvaluatorFloatXObjectOr, float, object, _operate_or)
969
OP_EVALUATOR(OperatorEvaluatorObjectXFloatOr, object, float, _operate_or)
970

971
// object
972
OP_EVALUATOR(OperatorEvaluatorObjectXObjectOr, object, object, _operate_or)
973

974
// AND
975

976
// nil
977
OP_EVALUATOR(OperatorEvaluatorNilXBoolAnd, nil, bool, _operate_and)
978
OP_EVALUATOR(OperatorEvaluatorBoolXNilAnd, bool, nil, _operate_and)
979

980
OP_EVALUATOR(OperatorEvaluatorNilXIntAnd, nil, int, _operate_and)
981
OP_EVALUATOR(OperatorEvaluatorIntXNilAnd, int, nil, _operate_and)
982

983
OP_EVALUATOR(OperatorEvaluatorNilXFloatAnd, nil, float, _operate_and)
984
OP_EVALUATOR(OperatorEvaluatorFloatXNilAnd, float, nil, _operate_and)
985

986
OP_EVALUATOR(OperatorEvaluatorObjectXNilAnd, object, nil, _operate_and)
987
OP_EVALUATOR(OperatorEvaluatorNilXObjectAnd, nil, object, _operate_and)
988

989
// bool
990
OP_EVALUATOR(OperatorEvaluatorBoolXBoolAnd, bool, bool, _operate_and)
991

992
OP_EVALUATOR(OperatorEvaluatorBoolXIntAnd, bool, int, _operate_and)
993
OP_EVALUATOR(OperatorEvaluatorIntXBoolAnd, int, bool, _operate_and)
994

995
OP_EVALUATOR(OperatorEvaluatorBoolXFloatAnd, bool, float, _operate_and)
996
OP_EVALUATOR(OperatorEvaluatorFloatXBoolAnd, float, bool, _operate_and)
997

998
OP_EVALUATOR(OperatorEvaluatorBoolXObjectAnd, bool, object, _operate_and)
999
OP_EVALUATOR(OperatorEvaluatorObjectXBoolAnd, object, bool, _operate_and)
1000

1001
// int
1002
OP_EVALUATOR(OperatorEvaluatorIntXIntAnd, int, int, _operate_and)
1003

1004
OP_EVALUATOR(OperatorEvaluatorIntXFloatAnd, int, float, _operate_and)
1005
OP_EVALUATOR(OperatorEvaluatorFloatXIntAnd, float, int, _operate_and)
1006

1007
OP_EVALUATOR(OperatorEvaluatorIntXObjectAnd, int, object, _operate_and)
1008
OP_EVALUATOR(OperatorEvaluatorObjectXIntAnd, object, int, _operate_and)
1009

1010
// float
1011
OP_EVALUATOR(OperatorEvaluatorFloatXFloatAnd, float, float, _operate_and)
1012

1013
OP_EVALUATOR(OperatorEvaluatorFloatXObjectAnd, float, object, _operate_and)
1014
OP_EVALUATOR(OperatorEvaluatorObjectXFloatAnd, object, float, _operate_and)
1015

1016
// object
1017
OP_EVALUATOR(OperatorEvaluatorObjectXObjectAnd, object, object, _operate_and)
1018

1019
// XOR
1020

1021
// nil
1022
OP_EVALUATOR(OperatorEvaluatorNilXBoolXor, nil, bool, _operate_xor)
1023
OP_EVALUATOR(OperatorEvaluatorBoolXNilXor, bool, nil, _operate_xor)
1024

1025
OP_EVALUATOR(OperatorEvaluatorNilXIntXor, nil, int, _operate_xor)
1026
OP_EVALUATOR(OperatorEvaluatorIntXNilXor, int, nil, _operate_xor)
1027

1028
OP_EVALUATOR(OperatorEvaluatorNilXFloatXor, nil, float, _operate_xor)
1029
OP_EVALUATOR(OperatorEvaluatorFloatXNilXor, float, nil, _operate_xor)
1030

1031
OP_EVALUATOR(OperatorEvaluatorObjectXNilXor, object, nil, _operate_xor)
1032
OP_EVALUATOR(OperatorEvaluatorNilXObjectXor, nil, object, _operate_xor)
1033

1034
// bool
1035
OP_EVALUATOR(OperatorEvaluatorBoolXBoolXor, bool, bool, _operate_xor)
1036

1037
OP_EVALUATOR(OperatorEvaluatorBoolXIntXor, bool, int, _operate_xor)
1038
OP_EVALUATOR(OperatorEvaluatorIntXBoolXor, int, bool, _operate_xor)
1039

1040
OP_EVALUATOR(OperatorEvaluatorBoolXFloatXor, bool, float, _operate_xor)
1041
OP_EVALUATOR(OperatorEvaluatorFloatXBoolXor, float, bool, _operate_xor)
1042

1043
OP_EVALUATOR(OperatorEvaluatorBoolXObjectXor, bool, object, _operate_xor)
1044
OP_EVALUATOR(OperatorEvaluatorObjectXBoolXor, object, bool, _operate_xor)
1045

1046
// int
1047
OP_EVALUATOR(OperatorEvaluatorIntXIntXor, int, int, _operate_xor)
1048

1049
OP_EVALUATOR(OperatorEvaluatorIntXFloatXor, int, float, _operate_xor)
1050
OP_EVALUATOR(OperatorEvaluatorFloatXIntXor, float, int, _operate_xor)
1051

1052
OP_EVALUATOR(OperatorEvaluatorIntXObjectXor, int, object, _operate_xor)
1053
OP_EVALUATOR(OperatorEvaluatorObjectXIntXor, object, int, _operate_xor)
1054

1055
// float
1056
OP_EVALUATOR(OperatorEvaluatorFloatXFloatXor, float, float, _operate_xor)
1057

1058
OP_EVALUATOR(OperatorEvaluatorFloatXObjectXor, float, object, _operate_xor)
1059
OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor)
1060

1061
// object
1062
OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
1063

1064
class OperatorEvaluatorNotBool : public CommonEvaluate<OperatorEvaluatorNotBool> {
1065
public:
1066
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1067
		VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<bool>::get(left);
1068
	}
1069
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1070
		PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
1071
	}
1072
	using ReturnType = bool;
1073
};
1074

1075
class OperatorEvaluatorNotInt : public CommonEvaluate<OperatorEvaluatorNotInt> {
1076
public:
1077
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1078
		VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<int64_t>::get(left);
1079
	}
1080
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1081
		PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
1082
	}
1083
	using ReturnType = bool;
1084
};
1085

1086
class OperatorEvaluatorNotFloat : public CommonEvaluate<OperatorEvaluatorNotFloat> {
1087
public:
1088
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1089
		VariantInternalAccessor<bool>::get(r_ret) = !VariantInternalAccessor<double>::get(left);
1090
	}
1091
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1092
		PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
1093
	}
1094
	using ReturnType = bool;
1095
};
1096

1097
class OperatorEvaluatorNotObject : public CommonEvaluate<OperatorEvaluatorNotObject> {
1098
public:
1099
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1100
		VariantInternalAccessor<bool>::get(r_ret) = left->get_validated_object() == nullptr;
1101
	}
1102
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1103
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
1104
	}
1105
	using ReturnType = bool;
1106
};
1107

1108
////
1109

1110
template <typename Left, typename Right>
1111
class OperatorEvaluatorInStringFind;
1112

1113
template <typename Left>
1114
class OperatorEvaluatorInStringFind<Left, String> : public CommonEvaluate<OperatorEvaluatorInStringFind<Left, String>> {
1115
public:
1116
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1117
		const Left &str_a = VariantInternalAccessor<Left>::get(left);
1118
		const String &str_b = VariantInternalAccessor<String>::get(right);
1119
		VariantInternalAccessor<bool>::get(r_ret) = str_b.find(str_a) != -1;
1120
	}
1121
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1122
		PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<Left>::convert(left)) != -1, r_ret);
1123
	}
1124
	using ReturnType = bool;
1125
};
1126

1127
template <typename Left>
1128
class OperatorEvaluatorInStringFind<Left, StringName> : public CommonEvaluate<OperatorEvaluatorInStringFind<Left, StringName>> {
1129
public:
1130
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1131
		const Left &str_a = VariantInternalAccessor<Left>::get(left);
1132
		const String str_b = VariantInternalAccessor<StringName>::get(right).operator String();
1133
		VariantInternalAccessor<bool>::get(r_ret) = str_b.find(str_a) != -1;
1134
	}
1135
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1136
		PtrToArg<bool>::encode(PtrToArg<StringName>::convert(right).operator String().find(PtrToArg<Left>::convert(left)) != -1, r_ret);
1137
	}
1138
	using ReturnType = bool;
1139
};
1140

1141
template <typename A, typename B>
1142
class OperatorEvaluatorInArrayFind : public CommonEvaluate<OperatorEvaluatorInArrayFind<A, B>> {
1143
public:
1144
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1145
		const A &a = VariantInternalAccessor<A>::get(left);
1146
		const B &b = VariantInternalAccessor<B>::get(right);
1147
		VariantInternalAccessor<bool>::get(r_ret) = b.find(a) != -1;
1148
	}
1149
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1150
		PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
1151
	}
1152
	using ReturnType = bool;
1153
};
1154

1155
class OperatorEvaluatorInArrayFindNil : public CommonEvaluate<OperatorEvaluatorInArrayFindNil> {
1156
public:
1157
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1158
		const Array &b = VariantInternalAccessor<Array>::get(right);
1159
		VariantInternalAccessor<bool>::get(r_ret) = b.find(Variant()) != -1;
1160
	}
1161
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1162
		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
1163
	}
1164
	using ReturnType = bool;
1165
};
1166

1167
class OperatorEvaluatorInArrayFindObject : public CommonEvaluate<OperatorEvaluatorInArrayFindObject> {
1168
public:
1169
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1170
		const Array &b = VariantInternalAccessor<Array>::get(right);
1171
		VariantInternalAccessor<bool>::get(r_ret) = b.find(*left) != -1;
1172
	}
1173
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1174
		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
1175
	}
1176
	using ReturnType = bool;
1177
};
1178

1179
template <typename A>
1180
class OperatorEvaluatorInDictionaryHas : public CommonEvaluate<OperatorEvaluatorInDictionaryHas<A>> {
1181
public:
1182
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1183
		const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
1184
		const A &a = VariantInternalAccessor<A>::get(left);
1185
		VariantInternalAccessor<bool>::get(r_ret) = b.has(a);
1186
	}
1187
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1188
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
1189
	}
1190
	using ReturnType = bool;
1191
};
1192

1193
class OperatorEvaluatorInDictionaryHasNil : public CommonEvaluate<OperatorEvaluatorInDictionaryHasNil> {
1194
public:
1195
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1196
		const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
1197
		VariantInternalAccessor<bool>::get(r_ret) = b.has(Variant());
1198
	}
1199
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1200
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
1201
	}
1202
	using ReturnType = bool;
1203
};
1204

1205
class OperatorEvaluatorInDictionaryHasObject : public CommonEvaluate<OperatorEvaluatorInDictionaryHasObject> {
1206
public:
1207
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1208
		const Dictionary &b = VariantInternalAccessor<Dictionary>::get(right);
1209
		VariantInternalAccessor<bool>::get(r_ret) = b.has(*left);
1210
	}
1211
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1212
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
1213
	}
1214
	using ReturnType = bool;
1215
};
1216

1217
class OperatorEvaluatorObjectHasPropertyString {
1218
public:
1219
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1220
		Object *b = p_right.get_validated_object();
1221
		if (!b) {
1222
			*r_ret = "Invalid base object for 'in'";
1223
			r_valid = false;
1224
			return;
1225
		}
1226

1227
		const String &a = VariantInternalAccessor<String>::get(&p_left);
1228

1229
		bool exist;
1230
		b->get(a, &exist);
1231
		*r_ret = exist;
1232
		r_valid = true;
1233
	}
1234
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1235
		Object *l = right->get_validated_object();
1236
		if (unlikely(!l)) {
1237
			VariantInternalAccessor<bool>::get(r_ret) = false;
1238
			ERR_FAIL_MSG("Invalid base object for 'in'.");
1239
		}
1240
		const String &a = VariantInternalAccessor<String>::get(left);
1241

1242
		bool valid;
1243
		l->get(a, &valid);
1244
		VariantInternalAccessor<bool>::get(r_ret) = valid;
1245
	}
1246
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1247
		bool valid;
1248
		PtrToArg<Object *>::convert(right)->get(PtrToArg<String>::convert(left), &valid);
1249
		PtrToArg<bool>::encode(valid, r_ret);
1250
	}
1251
	static Variant::Type get_return_type() { return Variant::BOOL; }
1252
};
1253

1254
class OperatorEvaluatorObjectHasPropertyStringName {
1255
public:
1256
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1257
		Object *b = p_right.get_validated_object();
1258
		if (!b) {
1259
			*r_ret = "Invalid base object for 'in'";
1260
			r_valid = false;
1261
			return;
1262
		}
1263

1264
		const StringName &a = VariantInternalAccessor<StringName>::get(&p_left);
1265

1266
		bool exist;
1267
		b->get(a, &exist);
1268
		*r_ret = exist;
1269
		r_valid = true;
1270
	}
1271
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1272
		Object *l = right->get_validated_object();
1273
		if (unlikely(!l)) {
1274
			VariantInternalAccessor<bool>::get(r_ret) = false;
1275
			ERR_FAIL_MSG("Invalid base object for 'in'.");
1276
		}
1277
		const StringName &a = VariantInternalAccessor<StringName>::get(left);
1278

1279
		bool valid;
1280
		l->get(a, &valid);
1281
		VariantInternalAccessor<bool>::get(r_ret) = valid;
1282
	}
1283
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1284
		bool valid;
1285
		PtrToArg<Object *>::convert(right)->get(PtrToArg<StringName>::convert(left), &valid);
1286
		PtrToArg<bool>::encode(valid, r_ret);
1287
	}
1288
	static Variant::Type get_return_type() { return Variant::BOOL; }
1289
};
1290

1291
Product

Resources

Company
