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 R, typename A, typename B>
39
class OperatorEvaluatorAdd {
40
public:
41
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
42
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
43
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
44
		*r_ret = a + b;
45
		r_valid = true;
46
	}
47
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
48
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) + *VariantGetInternalPtr<B>::get_ptr(right);
49
	}
50
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
51
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) + PtrToArg<B>::convert(right), r_ret);
52
	}
53
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
54
};
55

56
template <typename R, typename A, typename B>
57
class OperatorEvaluatorSub {
58
public:
59
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
60
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
61
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
62
		*r_ret = a - b;
63
		r_valid = true;
64
	}
65
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
66
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) - *VariantGetInternalPtr<B>::get_ptr(right);
67
	}
68
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
69
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) - PtrToArg<B>::convert(right), r_ret);
70
	}
71
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
72
};
73

74
template <typename R, typename A, typename B>
75
class OperatorEvaluatorMul {
76
public:
77
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
78
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
79
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
80
		*r_ret = a * b;
81
		r_valid = true;
82
	}
83
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
84
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) * *VariantGetInternalPtr<B>::get_ptr(right);
85
	}
86
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
87
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) * PtrToArg<B>::convert(right), r_ret);
88
	}
89
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
90
};
91

92
template <typename R, typename A, typename B>
93
class OperatorEvaluatorPow {
94
public:
95
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
96
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
97
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
98
		*r_ret = R(Math::pow((double)a, (double)b));
99
		r_valid = true;
100
	}
101
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
102
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = R(Math::pow((double)*VariantGetInternalPtr<A>::get_ptr(left), (double)*VariantGetInternalPtr<B>::get_ptr(right)));
103
	}
104
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
105
		PtrToArg<R>::encode(R(Math::pow((double)PtrToArg<A>::convert(left), (double)PtrToArg<B>::convert(right))), r_ret);
106
	}
107
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
108
};
109

110
template <typename R, typename A, typename B>
111
class OperatorEvaluatorXForm {
112
public:
113
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
114
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
115
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
116
		*r_ret = a.xform(b);
117
		r_valid = true;
118
	}
119
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
120
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<A>::get_ptr(left)->xform(*VariantGetInternalPtr<B>::get_ptr(right));
121
	}
122
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
123
		PtrToArg<R>::encode(PtrToArg<A>::convert(left).xform(PtrToArg<B>::convert(right)), r_ret);
124
	}
125
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
126
};
127

128
template <typename R, typename A, typename B>
129
class OperatorEvaluatorXFormInv {
130
public:
131
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
132
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
133
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
134
		*r_ret = b.xform_inv(a);
135
		r_valid = true;
136
	}
137
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
138
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = VariantGetInternalPtr<B>::get_ptr(right)->xform_inv(*VariantGetInternalPtr<A>::get_ptr(left));
139
	}
140
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
141
		PtrToArg<R>::encode(PtrToArg<B>::convert(right).xform_inv(PtrToArg<A>::convert(left)), r_ret);
142
	}
143
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
144
};
145

146
template <typename R, typename A, typename B>
147
class OperatorEvaluatorDiv {
148
public:
149
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
150
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
151
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
152
		*r_ret = a / b;
153
		r_valid = true;
154
	}
155
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
156
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
157
	}
158
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
159
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
160
	}
161
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
162
};
163

164
template <typename R, typename A, typename B>
165
class OperatorEvaluatorDivNZ {
166
public:
167
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
168
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
169
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
170
		if (b == 0) {
171
			r_valid = false;
172
			*r_ret = "Division by zero error";
173
			return;
174
		}
175
		*r_ret = a / b;
176
		r_valid = true;
177
	}
178
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
179
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) / *VariantGetInternalPtr<B>::get_ptr(right);
180
	}
181
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
182
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) / PtrToArg<B>::convert(right), r_ret);
183
	}
184
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
185
};
186

187
template <>
188
class OperatorEvaluatorDivNZ<Vector2i, Vector2i, Vector2i> {
189
public:
190
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
191
		const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
192
		const Vector2i &b = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
193
		if (unlikely(b.x == 0 || b.y == 0)) {
194
			r_valid = false;
195
			*r_ret = "Division by zero error";
196
			return;
197
		}
198
		*r_ret = a / b;
199
		r_valid = true;
200
	}
201
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
202
		VariantTypeChanger<Vector2i>::change(r_ret);
203
		*VariantGetInternalPtr<Vector2i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector2i>::get_ptr(left) / *VariantGetInternalPtr<Vector2i>::get_ptr(right);
204
	}
205
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
206
		PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) / PtrToArg<Vector2i>::convert(right), r_ret);
207
	}
208
	static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
209
};
210

211
template <>
212
class OperatorEvaluatorDivNZ<Vector3i, Vector3i, Vector3i> {
213
public:
214
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
215
		const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
216
		const Vector3i &b = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
217
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
218
			r_valid = false;
219
			*r_ret = "Division by zero error";
220
			return;
221
		}
222
		*r_ret = a / b;
223
		r_valid = true;
224
	}
225
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
226
		VariantTypeChanger<Vector3i>::change(r_ret);
227
		*VariantGetInternalPtr<Vector3i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector3i>::get_ptr(left) / *VariantGetInternalPtr<Vector3i>::get_ptr(right);
228
	}
229
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
230
		PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) / PtrToArg<Vector3i>::convert(right), r_ret);
231
	}
232
	static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
233
};
234

235
template <>
236
class OperatorEvaluatorDivNZ<Vector4i, Vector4i, Vector4i> {
237
public:
238
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
239
		const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
240
		const Vector4i &b = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
241
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
242
			r_valid = false;
243
			*r_ret = "Division by zero error";
244
			return;
245
		}
246
		*r_ret = a / b;
247
		r_valid = true;
248
	}
249
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
250
		VariantTypeChanger<Vector4i>::change(r_ret);
251
		*VariantGetInternalPtr<Vector4i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector4i>::get_ptr(left) / *VariantGetInternalPtr<Vector4i>::get_ptr(right);
252
	}
253
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
254
		PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) / PtrToArg<Vector4i>::convert(right), r_ret);
255
	}
256
	static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
257
};
258

259
template <typename R, typename A, typename B>
260
class OperatorEvaluatorMod {
261
public:
262
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
263
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
264
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
265
		*r_ret = a % b;
266
		r_valid = true;
267
	}
268
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
269
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
270
	}
271
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
272
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
273
	}
274
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
275
};
276

277
template <typename R, typename A, typename B>
278
class OperatorEvaluatorModNZ {
279
public:
280
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
281
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
282
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
283
		if (b == 0) {
284
			r_valid = false;
285
			*r_ret = "Modulo by zero error";
286
			return;
287
		}
288
		*r_ret = a % b;
289
		r_valid = true;
290
	}
291
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
292
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) % *VariantGetInternalPtr<B>::get_ptr(right);
293
	}
294
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
295
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) % PtrToArg<B>::convert(right), r_ret);
296
	}
297
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
298
};
299

300
template <>
301
class OperatorEvaluatorModNZ<Vector2i, Vector2i, Vector2i> {
302
public:
303
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
304
		const Vector2i &a = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_left);
305
		const Vector2i &b = *VariantGetInternalPtr<Vector2i>::get_ptr(&p_right);
306
		if (unlikely(b.x == 0 || b.y == 0)) {
307
			r_valid = false;
308
			*r_ret = "Modulo by zero error";
309
			return;
310
		}
311
		*r_ret = a % b;
312
		r_valid = true;
313
	}
314
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
315
		VariantTypeChanger<Vector2i>::change(r_ret);
316
		*VariantGetInternalPtr<Vector2i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector2i>::get_ptr(left) % *VariantGetInternalPtr<Vector2i>::get_ptr(right);
317
	}
318
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
319
		PtrToArg<Vector2i>::encode(PtrToArg<Vector2i>::convert(left) % PtrToArg<Vector2i>::convert(right), r_ret);
320
	}
321
	static Variant::Type get_return_type() { return GetTypeInfo<Vector2i>::VARIANT_TYPE; }
322
};
323

324
template <>
325
class OperatorEvaluatorModNZ<Vector3i, Vector3i, Vector3i> {
326
public:
327
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
328
		const Vector3i &a = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_left);
329
		const Vector3i &b = *VariantGetInternalPtr<Vector3i>::get_ptr(&p_right);
330
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0)) {
331
			r_valid = false;
332
			*r_ret = "Modulo by zero error";
333
			return;
334
		}
335
		*r_ret = a % b;
336
		r_valid = true;
337
	}
338
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
339
		VariantTypeChanger<Vector3i>::change(r_ret);
340
		*VariantGetInternalPtr<Vector3i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector3i>::get_ptr(left) % *VariantGetInternalPtr<Vector3i>::get_ptr(right);
341
	}
342
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
343
		PtrToArg<Vector3i>::encode(PtrToArg<Vector3i>::convert(left) % PtrToArg<Vector3i>::convert(right), r_ret);
344
	}
345
	static Variant::Type get_return_type() { return GetTypeInfo<Vector3i>::VARIANT_TYPE; }
346
};
347

348
template <>
349
class OperatorEvaluatorModNZ<Vector4i, Vector4i, Vector4i> {
350
public:
351
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
352
		const Vector4i &a = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_left);
353
		const Vector4i &b = *VariantGetInternalPtr<Vector4i>::get_ptr(&p_right);
354
		if (unlikely(b.x == 0 || b.y == 0 || b.z == 0 || b.w == 0)) {
355
			r_valid = false;
356
			*r_ret = "Modulo by zero error";
357
			return;
358
		}
359
		*r_ret = a % b;
360
		r_valid = true;
361
	}
362
	static void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
363
		VariantTypeChanger<Vector4i>::change(r_ret);
364
		*VariantGetInternalPtr<Vector4i>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector4i>::get_ptr(left) % *VariantGetInternalPtr<Vector4i>::get_ptr(right);
365
	}
366
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
367
		PtrToArg<Vector4i>::encode(PtrToArg<Vector4i>::convert(left) % PtrToArg<Vector4i>::convert(right), r_ret);
368
	}
369
	static Variant::Type get_return_type() { return GetTypeInfo<Vector4i>::VARIANT_TYPE; }
370
};
371

372
template <typename R, typename A>
373
class OperatorEvaluatorNeg {
374
public:
375
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
376
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
377
		*r_ret = -a;
378
		r_valid = true;
379
	}
380
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
381
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = -*VariantGetInternalPtr<A>::get_ptr(left);
382
	}
383
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
384
		PtrToArg<R>::encode(-PtrToArg<A>::convert(left), r_ret);
385
	}
386
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
387
};
388

389
template <typename R, typename A>
390
class OperatorEvaluatorPos {
391
public:
392
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
393
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
394
		*r_ret = a;
395
		r_valid = true;
396
	}
397
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
398
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left);
399
	}
400
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
401
		PtrToArg<R>::encode(PtrToArg<A>::convert(left), r_ret);
402
	}
403
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
404
};
405

406
template <typename R, typename A, typename B>
407
class OperatorEvaluatorShiftLeft {
408
public:
409
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
410
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
411
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
412

413
#if defined(DEBUG_ENABLED)
414
		if (b < 0 || a < 0) {
415
			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
416
			r_valid = false;
417
			return;
418
		}
419
#endif
420
		*r_ret = a << b;
421
		r_valid = true;
422
	}
423
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
424
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) << *VariantGetInternalPtr<B>::get_ptr(right);
425
	}
426
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
427
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) << PtrToArg<B>::convert(right), r_ret);
428
	}
429
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
430
};
431

432
template <typename R, typename A, typename B>
433
class OperatorEvaluatorShiftRight {
434
public:
435
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
436
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
437
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
438

439
#if defined(DEBUG_ENABLED)
440
		if (b < 0 || a < 0) {
441
			*r_ret = "Invalid operands for bit shifting. Only positive operands are supported.";
442
			r_valid = false;
443
			return;
444
		}
445
#endif
446
		*r_ret = a >> b;
447
		r_valid = true;
448
	}
449
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
450
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >> *VariantGetInternalPtr<B>::get_ptr(right);
451
	}
452
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
453
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) >> PtrToArg<B>::convert(right), r_ret);
454
	}
455
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
456
};
457

458
template <typename R, typename A, typename B>
459
class OperatorEvaluatorBitOr {
460
public:
461
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
462
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
463
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
464
		*r_ret = a | b;
465
		r_valid = true;
466
	}
467
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
468
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) | *VariantGetInternalPtr<B>::get_ptr(right);
469
	}
470
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
471
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) | PtrToArg<B>::convert(right), r_ret);
472
	}
473
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
474
};
475

476
template <typename R, typename A, typename B>
477
class OperatorEvaluatorBitAnd {
478
public:
479
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
480
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
481
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
482
		*r_ret = a & b;
483
		r_valid = true;
484
	}
485
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
486
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) & *VariantGetInternalPtr<B>::get_ptr(right);
487
	}
488
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
489
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) & PtrToArg<B>::convert(right), r_ret);
490
	}
491
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
492
};
493

494
template <typename R, typename A, typename B>
495
class OperatorEvaluatorBitXor {
496
public:
497
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
498
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
499
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
500
		*r_ret = a ^ b;
501
		r_valid = true;
502
	}
503
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
504
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) ^ *VariantGetInternalPtr<B>::get_ptr(right);
505
	}
506
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
507
		PtrToArg<R>::encode(PtrToArg<A>::convert(left) ^ PtrToArg<B>::convert(right), r_ret);
508
	}
509
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
510
};
511

512
template <typename R, typename A>
513
class OperatorEvaluatorBitNeg {
514
public:
515
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
516
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
517
		*r_ret = ~a;
518
		r_valid = true;
519
	}
520
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
521
		*VariantGetInternalPtr<R>::get_ptr(r_ret) = ~*VariantGetInternalPtr<A>::get_ptr(left);
522
	}
523
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
524
		PtrToArg<R>::encode(~PtrToArg<A>::convert(left), r_ret);
525
	}
526
	static Variant::Type get_return_type() { return GetTypeInfo<R>::VARIANT_TYPE; }
527
};
528

529
template <typename A, typename B>
530
class OperatorEvaluatorEqual {
531
public:
532
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
533
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
534
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
535
		*r_ret = a == b;
536
		r_valid = true;
537
	}
538
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
539
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) == *VariantGetInternalPtr<B>::get_ptr(right);
540
	}
541
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
542
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == PtrToArg<B>::convert(right), r_ret);
543
	}
544
	static Variant::Type get_return_type() { return Variant::BOOL; }
545
};
546

547
class OperatorEvaluatorEqualObject {
548
public:
549
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
550
		const Object *a = p_left.get_validated_object();
551
		const Object *b = p_right.get_validated_object();
552
		*r_ret = a == b;
553
		r_valid = true;
554
	}
555
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
556
		const Object *a = left->get_validated_object();
557
		const Object *b = right->get_validated_object();
558
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == b;
559
	}
560
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
561
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == PtrToArg<Object *>::convert(right), r_ret);
562
	}
563
	static Variant::Type get_return_type() { return Variant::BOOL; }
564
};
565

566
class OperatorEvaluatorEqualObjectNil {
567
public:
568
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
569
		const Object *a = p_left.get_validated_object();
570
		*r_ret = a == nullptr;
571
		r_valid = true;
572
	}
573
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
574
		const Object *a = left->get_validated_object();
575
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a == nullptr;
576
	}
577
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
578
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
579
	}
580
	static Variant::Type get_return_type() { return Variant::BOOL; }
581
};
582

583
class OperatorEvaluatorEqualNilObject {
584
public:
585
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
586
		const Object *b = p_right.get_validated_object();
587
		*r_ret = nullptr == b;
588
		r_valid = true;
589
	}
590
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
591
		const Object *b = right->get_validated_object();
592
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr == b;
593
	}
594
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
595
		PtrToArg<bool>::encode(nullptr == PtrToArg<Object *>::convert(right), r_ret);
596
	}
597
	static Variant::Type get_return_type() { return Variant::BOOL; }
598
};
599

600
template <typename A, typename B>
601
class OperatorEvaluatorNotEqual {
602
public:
603
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
604
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
605
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
606
		*r_ret = a != b;
607
		r_valid = true;
608
	}
609
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
610
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) != *VariantGetInternalPtr<B>::get_ptr(right);
611
	}
612
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
613
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) != PtrToArg<B>::convert(right), r_ret);
614
	}
615
	static Variant::Type get_return_type() { return Variant::BOOL; }
616
};
617

618
class OperatorEvaluatorNotEqualObject {
619
public:
620
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
621
		Object *a = p_left.get_validated_object();
622
		Object *b = p_right.get_validated_object();
623
		*r_ret = a != b;
624
		r_valid = true;
625
	}
626
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
627
		Object *a = left->get_validated_object();
628
		Object *b = right->get_validated_object();
629
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != b;
630
	}
631
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
632
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != PtrToArg<Object *>::convert(right), r_ret);
633
	}
634
	static Variant::Type get_return_type() { return Variant::BOOL; }
635
};
636

637
class OperatorEvaluatorNotEqualObjectNil {
638
public:
639
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
640
		Object *a = p_left.get_validated_object();
641
		*r_ret = a != nullptr;
642
		r_valid = true;
643
	}
644
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
645
		Object *a = left->get_validated_object();
646
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = a != nullptr;
647
	}
648
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
649
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) != nullptr, r_ret);
650
	}
651
	static Variant::Type get_return_type() { return Variant::BOOL; }
652
};
653

654
class OperatorEvaluatorNotEqualNilObject {
655
public:
656
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
657
		Object *b = p_right.get_validated_object();
658
		*r_ret = nullptr != b;
659
		r_valid = true;
660
	}
661
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
662
		Object *b = right->get_validated_object();
663
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = nullptr != b;
664
	}
665
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
666
		PtrToArg<bool>::encode(nullptr != PtrToArg<Object *>::convert(right), r_ret);
667
	}
668
	static Variant::Type get_return_type() { return Variant::BOOL; }
669
};
670

671
template <typename A, typename B>
672
class OperatorEvaluatorLess {
673
public:
674
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
675
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
676
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
677
		*r_ret = a < b;
678
		r_valid = true;
679
	}
680
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
681
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) < *VariantGetInternalPtr<B>::get_ptr(right);
682
	}
683
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
684
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) < PtrToArg<B>::convert(right), r_ret);
685
	}
686
	static Variant::Type get_return_type() { return Variant::BOOL; }
687
};
688

689
template <typename A, typename B>
690
class OperatorEvaluatorLessEqual {
691
public:
692
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
693
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
694
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
695
		*r_ret = a <= b;
696
		r_valid = true;
697
	}
698
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
699
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) <= *VariantGetInternalPtr<B>::get_ptr(right);
700
	}
701
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
702
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) <= PtrToArg<B>::convert(right), r_ret);
703
	}
704
	static Variant::Type get_return_type() { return Variant::BOOL; }
705
};
706

707
template <typename A, typename B>
708
class OperatorEvaluatorGreater {
709
public:
710
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
711
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
712
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
713
		*r_ret = a > b;
714
		r_valid = true;
715
	}
716
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
717
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) > *VariantGetInternalPtr<B>::get_ptr(right);
718
	}
719
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
720
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) > PtrToArg<B>::convert(right), r_ret);
721
	}
722
	static Variant::Type get_return_type() { return Variant::BOOL; }
723
};
724

725
template <typename A, typename B>
726
class OperatorEvaluatorGreaterEqual {
727
public:
728
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
729
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
730
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
731
		*r_ret = a >= b;
732
		r_valid = true;
733
	}
734
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
735
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) >= *VariantGetInternalPtr<B>::get_ptr(right);
736
	}
737
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
738
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) >= PtrToArg<B>::convert(right), r_ret);
739
	}
740
	static Variant::Type get_return_type() { return Variant::BOOL; }
741
};
742

743
template <typename A, typename B>
744
class OperatorEvaluatorAnd {
745
public:
746
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
747
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
748
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
749
		*r_ret = a && b;
750
		r_valid = true;
751
	}
752
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
753
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) && *VariantGetInternalPtr<B>::get_ptr(right);
754
	}
755
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
756
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) && PtrToArg<B>::convert(right), r_ret);
757
	}
758
	static Variant::Type get_return_type() { return Variant::BOOL; }
759
};
760

761
template <typename A, typename B>
762
class OperatorEvaluatorOr {
763
public:
764
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
765
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
766
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
767
		*r_ret = a || b;
768
		r_valid = true;
769
	}
770
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
771
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) || *VariantGetInternalPtr<B>::get_ptr(right);
772
	}
773
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
774
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) || PtrToArg<B>::convert(right), r_ret);
775
	}
776
	static Variant::Type get_return_type() { return Variant::BOOL; }
777
};
778

779
#define XOR_OP(m_a, m_b) (((m_a) || (m_b)) && !((m_a) && (m_b)))
780
template <typename A, typename B>
781
class OperatorEvaluatorXor {
782
public:
783
	_FORCE_INLINE_ static bool xor_op(const A &a, const B &b) {
784
		return ((a) || (b)) && !((a) && (b));
785
	}
786
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
787
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
788
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
789
		*r_ret = xor_op(a, b);
790
		r_valid = true;
791
	}
792
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
793
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = xor_op(*VariantGetInternalPtr<A>::get_ptr(left), *VariantGetInternalPtr<B>::get_ptr(right));
794
	}
795
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
796
		PtrToArg<bool>::encode(xor_op(PtrToArg<A>::convert(left), PtrToArg<B>::convert(right)), r_ret);
797
	}
798
	static Variant::Type get_return_type() { return Variant::BOOL; }
799
};
800

801
template <typename A>
802
class OperatorEvaluatorNot {
803
public:
804
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
805
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
806
		*r_ret = a == A();
807
		r_valid = true;
808
	}
809
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
810
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = *VariantGetInternalPtr<A>::get_ptr(left) == A();
811
	}
812
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
813
		PtrToArg<bool>::encode(PtrToArg<A>::convert(left) == A(), r_ret);
814
	}
815
	static Variant::Type get_return_type() { return Variant::BOOL; }
816
};
817

818
//// CUSTOM ////
819

820
class OperatorEvaluatorAddArray {
821
public:
822
	_FORCE_INLINE_ static void _add_arrays(Array &sum, const Array &array_a, const Array &array_b) {
823
		int asize = array_a.size();
824
		int bsize = array_b.size();
825

826
		if (array_a.is_typed() && array_a.is_same_typed(array_b)) {
827
			sum.set_typed(array_a.get_typed_builtin(), array_a.get_typed_class_name(), array_a.get_typed_script());
828
		}
829

830
		sum.resize(asize + bsize);
831
		for (int i = 0; i < asize; i++) {
832
			sum[i] = array_a[i];
833
		}
834
		for (int i = 0; i < bsize; i++) {
835
			sum[i + asize] = array_b[i];
836
		}
837
	}
838
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
839
		const Array &array_a = *VariantGetInternalPtr<Array>::get_ptr(&p_left);
840
		const Array &array_b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
841
		Array sum;
842
		_add_arrays(sum, array_a, array_b);
843
		*r_ret = sum;
844
		r_valid = true;
845
	}
846
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
847
		*r_ret = Array();
848
		_add_arrays(*VariantGetInternalPtr<Array>::get_ptr(r_ret), *VariantGetInternalPtr<Array>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right));
849
	}
850
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
851
		Array ret;
852
		_add_arrays(ret, PtrToArg<Array>::convert(left), PtrToArg<Array>::convert(right));
853
		PtrToArg<Array>::encode(ret, r_ret);
854
	}
855
	static Variant::Type get_return_type() { return Variant::ARRAY; }
856
};
857

858
template <typename T>
859
class OperatorEvaluatorAppendArray {
860
public:
861
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
862
		const Vector<T> &array_a = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_left);
863
		const Vector<T> &array_b = *VariantGetInternalPtr<Vector<T>>::get_ptr(&p_right);
864
		Vector<T> sum = array_a;
865
		sum.append_array(array_b);
866
		*r_ret = sum;
867
		r_valid = true;
868
	}
869
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
870
		*VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret) = *VariantGetInternalPtr<Vector<T>>::get_ptr(left);
871
		VariantGetInternalPtr<Vector<T>>::get_ptr(r_ret)->append_array(*VariantGetInternalPtr<Vector<T>>::get_ptr(right));
872
	}
873
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
874
		Vector<T> sum = PtrToArg<Vector<T>>::convert(left);
875
		sum.append_array(PtrToArg<Vector<T>>::convert(right));
876
		PtrToArg<Vector<T>>::encode(sum, r_ret);
877
	}
878
	static Variant::Type get_return_type() { return GetTypeInfo<Vector<T>>::VARIANT_TYPE; }
879
};
880

881
template <typename Left, typename Right>
882
class OperatorEvaluatorStringConcat {
883
public:
884
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
885
		const String a(*VariantGetInternalPtr<Left>::get_ptr(&p_left));
886
		const String b(*VariantGetInternalPtr<Right>::get_ptr(&p_right));
887
		*r_ret = a + b;
888
		r_valid = true;
889
	}
890
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
891
		const String a(*VariantGetInternalPtr<Left>::get_ptr(left));
892
		const String b(*VariantGetInternalPtr<Right>::get_ptr(right));
893
		*VariantGetInternalPtr<String>::get_ptr(r_ret) = a + b;
894
	}
895
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
896
		const String a(PtrToArg<Left>::convert(left));
897
		const String b(PtrToArg<Right>::convert(right));
898
		PtrToArg<String>::encode(a + b, r_ret);
899
	}
900
	static Variant::Type get_return_type() { return Variant::STRING; }
901
};
902

903
template <typename S, typename T>
904
class OperatorEvaluatorStringFormat;
905

906
template <typename S>
907
class OperatorEvaluatorStringFormat<S, void> {
908
public:
909
	_FORCE_INLINE_ static String do_mod(const String &s, bool *r_valid) {
910
		Array values = { Variant() };
911
		String a = s.sprintf(values, r_valid);
912
		if (r_valid) {
913
			*r_valid = !*r_valid;
914
		}
915
		return a;
916
	}
917
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
918
		*r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), &r_valid);
919
	}
920
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
921
		bool valid = true;
922
		String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), &valid);
923
		if (unlikely(!valid)) {
924
			*VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
925
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
926
		}
927
		*VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
928
	}
929
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
930
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), nullptr), r_ret);
931
	}
932
	static Variant::Type get_return_type() { return Variant::STRING; }
933
};
934

935
template <typename S>
936
class OperatorEvaluatorStringFormat<S, Array> {
937
public:
938
	_FORCE_INLINE_ static String do_mod(const String &s, const Array &p_values, bool *r_valid) {
939
		String a = s.sprintf(p_values, r_valid);
940
		if (r_valid) {
941
			*r_valid = !*r_valid;
942
		}
943
		return a;
944
	}
945
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
946
		*r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), *VariantGetInternalPtr<Array>::get_ptr(&p_right), &r_valid);
947
	}
948
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
949
		bool valid = true;
950
		String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), *VariantGetInternalPtr<Array>::get_ptr(right), &valid);
951
		if (unlikely(!valid)) {
952
			*VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
953
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
954
		}
955
		*VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
956
	}
957
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
958
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Array>::convert(right), nullptr), r_ret);
959
	}
960
	static Variant::Type get_return_type() { return Variant::STRING; }
961
};
962

963
template <typename S>
964
class OperatorEvaluatorStringFormat<S, Object> {
965
public:
966
	_FORCE_INLINE_ static String do_mod(const String &s, const Object *p_object, bool *r_valid) {
967
		Array values = { p_object };
968
		String a = s.sprintf(values, r_valid);
969
		if (r_valid) {
970
			*r_valid = !*r_valid;
971
		}
972

973
		return a;
974
	}
975
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
976
		*r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), p_right.get_validated_object(), &r_valid);
977
	}
978
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
979
		bool valid = true;
980
		String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), right->get_validated_object(), &valid);
981
		if (unlikely(!valid)) {
982
			*VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
983
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
984
		}
985
		*VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
986
	}
987
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
988
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<Object *>::convert(right), nullptr), r_ret);
989
	}
990
	static Variant::Type get_return_type() { return Variant::STRING; }
991
};
992

993
template <typename S, typename T>
994
class OperatorEvaluatorStringFormat {
995
public:
996
	_FORCE_INLINE_ static String do_mod(const String &s, const T &p_value, bool *r_valid) {
997
		Array values = { p_value };
998
		String a = s.sprintf(values, r_valid);
999
		if (r_valid) {
1000
			*r_valid = !*r_valid;
1001
		}
1002
		return a;
1003
	}
1004
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1005
		*r_ret = do_mod(*VariantGetInternalPtr<S>::get_ptr(&p_left), *VariantGetInternalPtr<T>::get_ptr(&p_right), &r_valid);
1006
	}
1007
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1008
		bool valid = true;
1009
		String result = do_mod(*VariantGetInternalPtr<S>::get_ptr(left), *VariantGetInternalPtr<T>::get_ptr(right), &valid);
1010
		if (unlikely(!valid)) {
1011
			*VariantGetInternalPtr<String>::get_ptr(r_ret) = *VariantGetInternalPtr<S>::get_ptr(left);
1012
			ERR_FAIL_MSG(vformat("String formatting error: %s.", result));
1013
		}
1014
		*VariantGetInternalPtr<String>::get_ptr(r_ret) = result;
1015
	}
1016
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1017
		PtrToArg<String>::encode(do_mod(PtrToArg<S>::convert(left), PtrToArg<T>::convert(right), nullptr), r_ret);
1018
	}
1019
	static Variant::Type get_return_type() { return Variant::STRING; }
1020
};
1021

1022
template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
1023
class OperatorEvaluatorAlwaysTrue {
1024
public:
1025
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1026
		*r_ret = true;
1027
		r_valid = true;
1028
	}
1029
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1030
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = true;
1031
	}
1032
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1033
		PtrToArg<bool>::encode(true, r_ret);
1034
	}
1035
	static Variant::Type get_return_type() { return Variant::BOOL; }
1036
};
1037

1038
template <Variant::Operator op, Variant::Type type_left, Variant::Type type_right>
1039
class OperatorEvaluatorAlwaysFalse {
1040
public:
1041
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1042
		*r_ret = false;
1043
		r_valid = true;
1044
	}
1045
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1046
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
1047
	}
1048
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1049
		PtrToArg<bool>::encode(false, r_ret);
1050
	}
1051
	static Variant::Type get_return_type() { return Variant::BOOL; }
1052
};
1053

1054
///// OR ///////
1055

1056
_FORCE_INLINE_ static bool _operate_or(bool p_left, bool p_right) {
1057
	return p_left || p_right;
1058
}
1059

1060
_FORCE_INLINE_ static bool _operate_and(bool p_left, bool p_right) {
1061
	return p_left && p_right;
1062
}
1063

1064
_FORCE_INLINE_ static bool _operate_xor(bool p_left, bool p_right) {
1065
	return (p_left || p_right) && !(p_left && p_right);
1066
}
1067

1068
_FORCE_INLINE_ static bool _operate_get_nil(const Variant *p_ptr) {
1069
	return p_ptr->get_validated_object() != nullptr;
1070
}
1071

1072
_FORCE_INLINE_ static bool _operate_get_bool(const Variant *p_ptr) {
1073
	return *VariantGetInternalPtr<bool>::get_ptr(p_ptr);
1074
}
1075

1076
_FORCE_INLINE_ static bool _operate_get_int(const Variant *p_ptr) {
1077
	return *VariantGetInternalPtr<int64_t>::get_ptr(p_ptr) != 0;
1078
}
1079

1080
_FORCE_INLINE_ static bool _operate_get_float(const Variant *p_ptr) {
1081
	return *VariantGetInternalPtr<double>::get_ptr(p_ptr) != 0.0;
1082
}
1083

1084
_FORCE_INLINE_ static bool _operate_get_object(const Variant *p_ptr) {
1085
	return p_ptr->get_validated_object() != nullptr;
1086
}
1087

1088
_FORCE_INLINE_ static bool _operate_get_ptr_nil(const void *p_ptr) {
1089
	return false;
1090
}
1091

1092
_FORCE_INLINE_ static bool _operate_get_ptr_bool(const void *p_ptr) {
1093
	return PtrToArg<bool>::convert(p_ptr);
1094
}
1095

1096
_FORCE_INLINE_ static bool _operate_get_ptr_int(const void *p_ptr) {
1097
	return PtrToArg<int64_t>::convert(p_ptr) != 0;
1098
}
1099

1100
_FORCE_INLINE_ static bool _operate_get_ptr_float(const void *p_ptr) {
1101
	return PtrToArg<double>::convert(p_ptr) != 0.0;
1102
}
1103

1104
_FORCE_INLINE_ static bool _operate_get_ptr_object(const void *p_ptr) {
1105
	return PtrToArg<Object *>::convert(p_ptr) != nullptr;
1106
}
1107

1108
#define OP_EVALUATOR(m_class_name, m_left, m_right, m_op)                                                                    \
1109
	class m_class_name {                                                                                                     \
1110
	public:                                                                                                                  \
1111
		static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {                 \
1112
			*r_ret = m_op(_operate_get_##m_left(&p_left), _operate_get_##m_right(&p_right));                                 \
1113
			r_valid = true;                                                                                                  \
1114
		}                                                                                                                    \
1115
                                                                                                                             \
1116
		static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {                   \
1117
			*VariantGetInternalPtr<bool>::get_ptr(r_ret) = m_op(_operate_get_##m_left(left), _operate_get_##m_right(right)); \
1118
		}                                                                                                                    \
1119
                                                                                                                             \
1120
		static void ptr_evaluate(const void *left, const void *right, void *r_ret) {                                         \
1121
			PtrToArg<bool>::encode(m_op(_operate_get_ptr_##m_left(left), _operate_get_ptr_##m_right(right)), r_ret);         \
1122
		}                                                                                                                    \
1123
                                                                                                                             \
1124
		static Variant::Type get_return_type() {                                                                             \
1125
			return Variant::BOOL;                                                                                            \
1126
		}                                                                                                                    \
1127
	};
1128

1129
// OR
1130

1131
// nil
1132
OP_EVALUATOR(OperatorEvaluatorNilXBoolOr, nil, bool, _operate_or)
1133
OP_EVALUATOR(OperatorEvaluatorBoolXNilOr, bool, nil, _operate_or)
1134

1135
OP_EVALUATOR(OperatorEvaluatorNilXIntOr, nil, int, _operate_or)
1136
OP_EVALUATOR(OperatorEvaluatorIntXNilOr, int, nil, _operate_or)
1137

1138
OP_EVALUATOR(OperatorEvaluatorNilXFloatOr, nil, float, _operate_or)
1139
OP_EVALUATOR(OperatorEvaluatorFloatXNilOr, float, nil, _operate_or)
1140

1141
OP_EVALUATOR(OperatorEvaluatorObjectXNilOr, object, nil, _operate_or)
1142
OP_EVALUATOR(OperatorEvaluatorNilXObjectOr, nil, object, _operate_or)
1143

1144
// bool
1145
OP_EVALUATOR(OperatorEvaluatorBoolXBoolOr, bool, bool, _operate_or)
1146

1147
OP_EVALUATOR(OperatorEvaluatorBoolXIntOr, bool, int, _operate_or)
1148
OP_EVALUATOR(OperatorEvaluatorIntXBoolOr, int, bool, _operate_or)
1149

1150
OP_EVALUATOR(OperatorEvaluatorBoolXFloatOr, bool, float, _operate_or)
1151
OP_EVALUATOR(OperatorEvaluatorFloatXBoolOr, float, bool, _operate_or)
1152

1153
OP_EVALUATOR(OperatorEvaluatorBoolXObjectOr, bool, object, _operate_or)
1154
OP_EVALUATOR(OperatorEvaluatorObjectXBoolOr, object, bool, _operate_or)
1155

1156
// int
1157
OP_EVALUATOR(OperatorEvaluatorIntXIntOr, int, int, _operate_or)
1158

1159
OP_EVALUATOR(OperatorEvaluatorIntXFloatOr, int, float, _operate_or)
1160
OP_EVALUATOR(OperatorEvaluatorFloatXIntOr, float, int, _operate_or)
1161

1162
OP_EVALUATOR(OperatorEvaluatorIntXObjectOr, int, object, _operate_or)
1163
OP_EVALUATOR(OperatorEvaluatorObjectXIntOr, object, int, _operate_or)
1164

1165
// float
1166
OP_EVALUATOR(OperatorEvaluatorFloatXFloatOr, float, float, _operate_or)
1167

1168
OP_EVALUATOR(OperatorEvaluatorFloatXObjectOr, float, object, _operate_or)
1169
OP_EVALUATOR(OperatorEvaluatorObjectXFloatOr, object, float, _operate_or)
1170

1171
// object
1172
OP_EVALUATOR(OperatorEvaluatorObjectXObjectOr, object, object, _operate_or)
1173

1174
// AND
1175

1176
// nil
1177
OP_EVALUATOR(OperatorEvaluatorNilXBoolAnd, nil, bool, _operate_and)
1178
OP_EVALUATOR(OperatorEvaluatorBoolXNilAnd, bool, nil, _operate_and)
1179

1180
OP_EVALUATOR(OperatorEvaluatorNilXIntAnd, nil, int, _operate_and)
1181
OP_EVALUATOR(OperatorEvaluatorIntXNilAnd, int, nil, _operate_and)
1182

1183
OP_EVALUATOR(OperatorEvaluatorNilXFloatAnd, nil, float, _operate_and)
1184
OP_EVALUATOR(OperatorEvaluatorFloatXNilAnd, float, nil, _operate_and)
1185

1186
OP_EVALUATOR(OperatorEvaluatorObjectXNilAnd, object, nil, _operate_and)
1187
OP_EVALUATOR(OperatorEvaluatorNilXObjectAnd, nil, object, _operate_and)
1188

1189
// bool
1190
OP_EVALUATOR(OperatorEvaluatorBoolXBoolAnd, bool, bool, _operate_and)
1191

1192
OP_EVALUATOR(OperatorEvaluatorBoolXIntAnd, bool, int, _operate_and)
1193
OP_EVALUATOR(OperatorEvaluatorIntXBoolAnd, int, bool, _operate_and)
1194

1195
OP_EVALUATOR(OperatorEvaluatorBoolXFloatAnd, bool, float, _operate_and)
1196
OP_EVALUATOR(OperatorEvaluatorFloatXBoolAnd, float, bool, _operate_and)
1197

1198
OP_EVALUATOR(OperatorEvaluatorBoolXObjectAnd, bool, object, _operate_and)
1199
OP_EVALUATOR(OperatorEvaluatorObjectXBoolAnd, object, bool, _operate_and)
1200

1201
// int
1202
OP_EVALUATOR(OperatorEvaluatorIntXIntAnd, int, int, _operate_and)
1203

1204
OP_EVALUATOR(OperatorEvaluatorIntXFloatAnd, int, float, _operate_and)
1205
OP_EVALUATOR(OperatorEvaluatorFloatXIntAnd, float, int, _operate_and)
1206

1207
OP_EVALUATOR(OperatorEvaluatorIntXObjectAnd, int, object, _operate_and)
1208
OP_EVALUATOR(OperatorEvaluatorObjectXIntAnd, object, int, _operate_and)
1209

1210
// float
1211
OP_EVALUATOR(OperatorEvaluatorFloatXFloatAnd, float, float, _operate_and)
1212

1213
OP_EVALUATOR(OperatorEvaluatorFloatXObjectAnd, float, object, _operate_and)
1214
OP_EVALUATOR(OperatorEvaluatorObjectXFloatAnd, object, float, _operate_and)
1215

1216
// object
1217
OP_EVALUATOR(OperatorEvaluatorObjectXObjectAnd, object, object, _operate_and)
1218

1219
// XOR
1220

1221
// nil
1222
OP_EVALUATOR(OperatorEvaluatorNilXBoolXor, nil, bool, _operate_xor)
1223
OP_EVALUATOR(OperatorEvaluatorBoolXNilXor, bool, nil, _operate_xor)
1224

1225
OP_EVALUATOR(OperatorEvaluatorNilXIntXor, nil, int, _operate_xor)
1226
OP_EVALUATOR(OperatorEvaluatorIntXNilXor, int, nil, _operate_xor)
1227

1228
OP_EVALUATOR(OperatorEvaluatorNilXFloatXor, nil, float, _operate_xor)
1229
OP_EVALUATOR(OperatorEvaluatorFloatXNilXor, float, nil, _operate_xor)
1230

1231
OP_EVALUATOR(OperatorEvaluatorObjectXNilXor, object, nil, _operate_xor)
1232
OP_EVALUATOR(OperatorEvaluatorNilXObjectXor, nil, object, _operate_xor)
1233

1234
// bool
1235
OP_EVALUATOR(OperatorEvaluatorBoolXBoolXor, bool, bool, _operate_xor)
1236

1237
OP_EVALUATOR(OperatorEvaluatorBoolXIntXor, bool, int, _operate_xor)
1238
OP_EVALUATOR(OperatorEvaluatorIntXBoolXor, int, bool, _operate_xor)
1239

1240
OP_EVALUATOR(OperatorEvaluatorBoolXFloatXor, bool, float, _operate_xor)
1241
OP_EVALUATOR(OperatorEvaluatorFloatXBoolXor, float, bool, _operate_xor)
1242

1243
OP_EVALUATOR(OperatorEvaluatorBoolXObjectXor, bool, object, _operate_xor)
1244
OP_EVALUATOR(OperatorEvaluatorObjectXBoolXor, object, bool, _operate_xor)
1245

1246
// int
1247
OP_EVALUATOR(OperatorEvaluatorIntXIntXor, int, int, _operate_xor)
1248

1249
OP_EVALUATOR(OperatorEvaluatorIntXFloatXor, int, float, _operate_xor)
1250
OP_EVALUATOR(OperatorEvaluatorFloatXIntXor, float, int, _operate_xor)
1251

1252
OP_EVALUATOR(OperatorEvaluatorIntXObjectXor, int, object, _operate_xor)
1253
OP_EVALUATOR(OperatorEvaluatorObjectXIntXor, object, int, _operate_xor)
1254

1255
// float
1256
OP_EVALUATOR(OperatorEvaluatorFloatXFloatXor, float, float, _operate_xor)
1257

1258
OP_EVALUATOR(OperatorEvaluatorFloatXObjectXor, float, object, _operate_xor)
1259
OP_EVALUATOR(OperatorEvaluatorObjectXFloatXor, object, float, _operate_xor)
1260

1261
// object
1262
OP_EVALUATOR(OperatorEvaluatorObjectXObjectXor, object, object, _operate_xor)
1263

1264
class OperatorEvaluatorNotBool {
1265
public:
1266
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1267
		*r_ret = !*VariantGetInternalPtr<bool>::get_ptr(&p_left);
1268
		r_valid = true;
1269
	}
1270
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1271
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<bool>::get_ptr(left);
1272
	}
1273
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1274
		PtrToArg<bool>::encode(!PtrToArg<bool>::convert(left), r_ret);
1275
	}
1276
	static Variant::Type get_return_type() { return Variant::BOOL; }
1277
};
1278

1279
class OperatorEvaluatorNotInt {
1280
public:
1281
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1282
		*r_ret = !*VariantGetInternalPtr<int64_t>::get_ptr(&p_left);
1283
		r_valid = true;
1284
	}
1285
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1286
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<int64_t>::get_ptr(left);
1287
	}
1288
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1289
		PtrToArg<bool>::encode(!PtrToArg<int64_t>::convert(left), r_ret);
1290
	}
1291
	static Variant::Type get_return_type() { return Variant::BOOL; }
1292
};
1293

1294
class OperatorEvaluatorNotFloat {
1295
public:
1296
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1297
		*r_ret = !*VariantGetInternalPtr<double>::get_ptr(&p_left);
1298
		r_valid = true;
1299
	}
1300
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1301
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = !*VariantGetInternalPtr<double>::get_ptr(left);
1302
	}
1303
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1304
		PtrToArg<bool>::encode(!PtrToArg<double>::convert(left), r_ret);
1305
	}
1306
	static Variant::Type get_return_type() { return Variant::BOOL; }
1307
};
1308

1309
class OperatorEvaluatorNotObject {
1310
public:
1311
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1312
		*r_ret = p_left.get_validated_object() == nullptr;
1313
		r_valid = true;
1314
	}
1315
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1316
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = left->get_validated_object() == nullptr;
1317
	}
1318
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1319
		PtrToArg<bool>::encode(PtrToArg<Object *>::convert(left) == nullptr, r_ret);
1320
	}
1321
	static Variant::Type get_return_type() { return Variant::BOOL; }
1322
};
1323

1324
////
1325

1326
template <typename Left, typename Right>
1327
class OperatorEvaluatorInStringFind;
1328

1329
template <typename Left>
1330
class OperatorEvaluatorInStringFind<Left, String> {
1331
public:
1332
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1333
		const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(&p_left);
1334
		const String &str_b = *VariantGetInternalPtr<String>::get_ptr(&p_right);
1335

1336
		*r_ret = str_b.find(str_a) != -1;
1337
		r_valid = true;
1338
	}
1339
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1340
		const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(left);
1341
		const String &str_b = *VariantGetInternalPtr<String>::get_ptr(right);
1342
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = str_b.find(str_a) != -1;
1343
	}
1344
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1345
		PtrToArg<bool>::encode(PtrToArg<String>::convert(right).find(PtrToArg<Left>::convert(left)) != -1, r_ret);
1346
	}
1347
	static Variant::Type get_return_type() { return Variant::BOOL; }
1348
};
1349

1350
template <typename Left>
1351
class OperatorEvaluatorInStringFind<Left, StringName> {
1352
public:
1353
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1354
		const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(&p_left);
1355
		const String str_b = VariantGetInternalPtr<StringName>::get_ptr(&p_right)->operator String();
1356

1357
		*r_ret = str_b.find(str_a) != -1;
1358
		r_valid = true;
1359
	}
1360
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1361
		const Left &str_a = *VariantGetInternalPtr<Left>::get_ptr(left);
1362
		const String str_b = VariantGetInternalPtr<StringName>::get_ptr(right)->operator String();
1363
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = str_b.find(str_a) != -1;
1364
	}
1365
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1366
		PtrToArg<bool>::encode(PtrToArg<StringName>::convert(right).operator String().find(PtrToArg<Left>::convert(left)) != -1, r_ret);
1367
	}
1368
	static Variant::Type get_return_type() { return Variant::BOOL; }
1369
};
1370

1371
template <typename A, typename B>
1372
class OperatorEvaluatorInArrayFind {
1373
public:
1374
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1375
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
1376
		const B &b = *VariantGetInternalPtr<B>::get_ptr(&p_right);
1377

1378
		*r_ret = b.find(a) != -1;
1379
		r_valid = true;
1380
	}
1381
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1382
		const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
1383
		const B &b = *VariantGetInternalPtr<B>::get_ptr(right);
1384
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(a) != -1;
1385
	}
1386
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1387
		PtrToArg<bool>::encode(PtrToArg<B>::convert(right).find(PtrToArg<A>::convert(left)) != -1, r_ret);
1388
	}
1389
	static Variant::Type get_return_type() { return Variant::BOOL; }
1390
};
1391

1392
class OperatorEvaluatorInArrayFindNil {
1393
public:
1394
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1395
		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
1396
		*r_ret = b.find(Variant()) != -1;
1397
		r_valid = true;
1398
	}
1399
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1400
		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
1401
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(Variant()) != -1;
1402
	}
1403
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1404
		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(Variant()) != -1, r_ret);
1405
	}
1406
	static Variant::Type get_return_type() { return Variant::BOOL; }
1407
};
1408

1409
class OperatorEvaluatorInArrayFindObject {
1410
public:
1411
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1412
		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(&p_right);
1413
		*r_ret = b.find(p_left) != -1;
1414
		r_valid = true;
1415
	}
1416
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1417
		const Array &b = *VariantGetInternalPtr<Array>::get_ptr(right);
1418
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.find(*left) != -1;
1419
	}
1420
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1421
		PtrToArg<bool>::encode(PtrToArg<Array>::convert(right).find(PtrToArg<Object *>::convert(left)) != -1, r_ret);
1422
	}
1423
	static Variant::Type get_return_type() { return Variant::BOOL; }
1424
};
1425

1426
template <typename A>
1427
class OperatorEvaluatorInDictionaryHas {
1428
public:
1429
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1430
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
1431
		const A &a = *VariantGetInternalPtr<A>::get_ptr(&p_left);
1432

1433
		*r_ret = b.has(a);
1434
		r_valid = true;
1435
	}
1436
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1437
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
1438
		const A &a = *VariantGetInternalPtr<A>::get_ptr(left);
1439
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(a);
1440
	}
1441
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1442
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<A>::convert(left)), r_ret);
1443
	}
1444
	static Variant::Type get_return_type() { return Variant::BOOL; }
1445
};
1446

1447
class OperatorEvaluatorInDictionaryHasNil {
1448
public:
1449
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1450
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
1451

1452
		*r_ret = b.has(Variant());
1453
		r_valid = true;
1454
	}
1455
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1456
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
1457
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(Variant());
1458
	}
1459
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1460
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(Variant()), r_ret);
1461
	}
1462
	static Variant::Type get_return_type() { return Variant::BOOL; }
1463
};
1464

1465
class OperatorEvaluatorInDictionaryHasObject {
1466
public:
1467
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1468
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(&p_right);
1469

1470
		*r_ret = b.has(p_left);
1471
		r_valid = true;
1472
	}
1473
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1474
		const Dictionary &b = *VariantGetInternalPtr<Dictionary>::get_ptr(right);
1475
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = b.has(*left);
1476
	}
1477
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1478
		PtrToArg<bool>::encode(PtrToArg<Dictionary>::convert(right).has(PtrToArg<Object *>::convert(left)), r_ret);
1479
	}
1480
	static Variant::Type get_return_type() { return Variant::BOOL; }
1481
};
1482

1483
class OperatorEvaluatorObjectHasPropertyString {
1484
public:
1485
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1486
		Object *b = p_right.get_validated_object();
1487
		if (!b) {
1488
			*r_ret = "Invalid base object for 'in'";
1489
			r_valid = false;
1490
			return;
1491
		}
1492

1493
		const String &a = *VariantGetInternalPtr<String>::get_ptr(&p_left);
1494

1495
		bool exist;
1496
		b->get(a, &exist);
1497
		*r_ret = exist;
1498
		r_valid = true;
1499
	}
1500
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1501
		Object *l = right->get_validated_object();
1502
		if (unlikely(!l)) {
1503
			*VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
1504
			ERR_FAIL_MSG("Invalid base object for 'in'.");
1505
		}
1506
		const String &a = *VariantGetInternalPtr<String>::get_ptr(left);
1507

1508
		bool valid;
1509
		l->get(a, &valid);
1510
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
1511
	}
1512
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1513
		bool valid;
1514
		PtrToArg<Object *>::convert(right)->get(PtrToArg<String>::convert(left), &valid);
1515
		PtrToArg<bool>::encode(valid, r_ret);
1516
	}
1517
	static Variant::Type get_return_type() { return Variant::BOOL; }
1518
};
1519

1520
class OperatorEvaluatorObjectHasPropertyStringName {
1521
public:
1522
	static void evaluate(const Variant &p_left, const Variant &p_right, Variant *r_ret, bool &r_valid) {
1523
		Object *b = p_right.get_validated_object();
1524
		if (!b) {
1525
			*r_ret = "Invalid base object for 'in'";
1526
			r_valid = false;
1527
			return;
1528
		}
1529

1530
		const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(&p_left);
1531

1532
		bool exist;
1533
		b->get(a, &exist);
1534
		*r_ret = exist;
1535
		r_valid = true;
1536
	}
1537
	static inline void validated_evaluate(const Variant *left, const Variant *right, Variant *r_ret) {
1538
		Object *l = right->get_validated_object();
1539
		if (unlikely(!l)) {
1540
			*VariantGetInternalPtr<bool>::get_ptr(r_ret) = false;
1541
			ERR_FAIL_MSG("Invalid base object for 'in'.");
1542
		}
1543
		const StringName &a = *VariantGetInternalPtr<StringName>::get_ptr(left);
1544

1545
		bool valid;
1546
		l->get(a, &valid);
1547
		*VariantGetInternalPtr<bool>::get_ptr(r_ret) = valid;
1548
	}
1549
	static void ptr_evaluate(const void *left, const void *right, void *r_ret) {
1550
		bool valid;
1551
		PtrToArg<Object *>::convert(right)->get(PtrToArg<StringName>::convert(left), &valid);
1552
		PtrToArg<bool>::encode(valid, r_ret);
1553
	}
1554
	static Variant::Type get_return_type() { return Variant::BOOL; }
1555
};
1556

1557
Product

Resources

Company
