1 /*************************************************************************/
2 /*  expression.cpp                                                       */
3 /*************************************************************************/
4 /*                       This file is part of:                           */
5 /*                           GODOT ENGINE                                */
6 /*                      https://godotengine.org                          */
7 /*************************************************************************/
8 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
9 /* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
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 #include "expression.h"
32 
33 #include "core/class_db.h"
34 #include "core/func_ref.h"
35 #include "core/io/marshalls.h"
36 #include "core/math/math_funcs.h"
37 #include "core/os/os.h"
38 #include "core/reference.h"
39 #include "core/variant_parser.h"
40 
41 const char *Expression::func_name[Expression::FUNC_MAX] = {
42 	"sin",
43 	"cos",
44 	"tan",
45 	"sinh",
46 	"cosh",
47 	"tanh",
48 	"asin",
49 	"acos",
50 	"atan",
51 	"atan2",
52 	"sqrt",
53 	"fmod",
54 	"fposmod",
55 	"posmod",
56 	"floor",
57 	"ceil",
58 	"round",
59 	"abs",
60 	"sign",
61 	"pow",
62 	"log",
63 	"exp",
64 	"is_nan",
65 	"is_inf",
66 	"ease",
67 	"decimals",
68 	"step_decimals",
69 	"stepify",
70 	"lerp",
71 	"lerp_angle",
72 	"inverse_lerp",
73 	"range_lerp",
74 	"smoothstep",
75 	"move_toward",
76 	"dectime",
77 	"randomize",
78 	"randi",
79 	"randf",
80 	"rand_range",
81 	"seed",
82 	"rand_seed",
83 	"deg2rad",
84 	"rad2deg",
85 	"linear2db",
86 	"db2linear",
87 	"polar2cartesian",
88 	"cartesian2polar",
89 	"wrapi",
90 	"wrapf",
91 	"max",
92 	"min",
93 	"clamp",
94 	"nearest_po2",
95 	"weakref",
96 	"funcref",
97 	"convert",
98 	"typeof",
99 	"type_exists",
100 	"char",
101 	"ord",
102 	"str",
103 	"print",
104 	"printerr",
105 	"printraw",
106 	"var2str",
107 	"str2var",
108 	"var2bytes",
109 	"bytes2var",
110 	"color_named",
111 };
112 
find_function(const String & p_string)113 Expression::BuiltinFunc Expression::find_function(const String &p_string) {
114 
115 	for (int i = 0; i < FUNC_MAX; i++) {
116 		if (p_string == func_name[i])
117 			return BuiltinFunc(i);
118 	}
119 
120 	return FUNC_MAX;
121 }
122 
get_func_name(BuiltinFunc p_func)123 String Expression::get_func_name(BuiltinFunc p_func) {
124 
125 	ERR_FAIL_INDEX_V(p_func, FUNC_MAX, String());
126 	return func_name[p_func];
127 }
128 
get_func_argument_count(BuiltinFunc p_func)129 int Expression::get_func_argument_count(BuiltinFunc p_func) {
130 
131 	switch (p_func) {
132 
133 		case MATH_RANDOMIZE:
134 		case MATH_RAND:
135 		case MATH_RANDF:
136 			return 0;
137 		case MATH_SIN:
138 		case MATH_COS:
139 		case MATH_TAN:
140 		case MATH_SINH:
141 		case MATH_COSH:
142 		case MATH_TANH:
143 		case MATH_ASIN:
144 		case MATH_ACOS:
145 		case MATH_ATAN:
146 		case MATH_SQRT:
147 		case MATH_FLOOR:
148 		case MATH_CEIL:
149 		case MATH_ROUND:
150 		case MATH_ABS:
151 		case MATH_SIGN:
152 		case MATH_LOG:
153 		case MATH_EXP:
154 		case MATH_ISNAN:
155 		case MATH_ISINF:
156 		case MATH_DECIMALS:
157 		case MATH_STEP_DECIMALS:
158 		case MATH_SEED:
159 		case MATH_RANDSEED:
160 		case MATH_DEG2RAD:
161 		case MATH_RAD2DEG:
162 		case MATH_LINEAR2DB:
163 		case MATH_DB2LINEAR:
164 		case LOGIC_NEAREST_PO2:
165 		case OBJ_WEAKREF:
166 		case TYPE_OF:
167 		case TEXT_CHAR:
168 		case TEXT_ORD:
169 		case TEXT_STR:
170 		case TEXT_PRINT:
171 		case TEXT_PRINTERR:
172 		case TEXT_PRINTRAW:
173 		case VAR_TO_STR:
174 		case STR_TO_VAR:
175 		case TYPE_EXISTS:
176 			return 1;
177 		case VAR_TO_BYTES:
178 		case BYTES_TO_VAR:
179 		case MATH_ATAN2:
180 		case MATH_FMOD:
181 		case MATH_FPOSMOD:
182 		case MATH_POSMOD:
183 		case MATH_POW:
184 		case MATH_EASE:
185 		case MATH_STEPIFY:
186 		case MATH_RANDOM:
187 		case MATH_POLAR2CARTESIAN:
188 		case MATH_CARTESIAN2POLAR:
189 		case LOGIC_MAX:
190 		case LOGIC_MIN:
191 		case FUNC_FUNCREF:
192 		case TYPE_CONVERT:
193 		case COLORN:
194 			return 2;
195 		case MATH_LERP:
196 		case MATH_LERP_ANGLE:
197 		case MATH_INVERSE_LERP:
198 		case MATH_SMOOTHSTEP:
199 		case MATH_MOVE_TOWARD:
200 		case MATH_DECTIME:
201 		case MATH_WRAP:
202 		case MATH_WRAPF:
203 		case LOGIC_CLAMP:
204 			return 3;
205 		case MATH_RANGE_LERP:
206 			return 5;
207 		case FUNC_MAX: {
208 		}
209 	}
210 	return 0;
211 }
212 
213 #define VALIDATE_ARG_NUM(m_arg)                                          \
214 	if (!p_inputs[m_arg]->is_num()) {                                    \
215 		r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; \
216 		r_error.argument = m_arg;                                        \
217 		r_error.expected = Variant::REAL;                                \
218 		return;                                                          \
219 	}
220 
exec_func(BuiltinFunc p_func,const Variant ** p_inputs,Variant * r_return,Variant::CallError & r_error,String & r_error_str)221 void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Variant::CallError &r_error, String &r_error_str) {
222 	r_error.error = Variant::CallError::CALL_OK;
223 	switch (p_func) {
224 		case MATH_SIN: {
225 
226 			VALIDATE_ARG_NUM(0);
227 			*r_return = Math::sin((double)*p_inputs[0]);
228 		} break;
229 		case MATH_COS: {
230 
231 			VALIDATE_ARG_NUM(0);
232 			*r_return = Math::cos((double)*p_inputs[0]);
233 		} break;
234 		case MATH_TAN: {
235 
236 			VALIDATE_ARG_NUM(0);
237 			*r_return = Math::tan((double)*p_inputs[0]);
238 		} break;
239 		case MATH_SINH: {
240 
241 			VALIDATE_ARG_NUM(0);
242 			*r_return = Math::sinh((double)*p_inputs[0]);
243 		} break;
244 		case MATH_COSH: {
245 
246 			VALIDATE_ARG_NUM(0);
247 			*r_return = Math::cosh((double)*p_inputs[0]);
248 		} break;
249 		case MATH_TANH: {
250 
251 			VALIDATE_ARG_NUM(0);
252 			*r_return = Math::tanh((double)*p_inputs[0]);
253 		} break;
254 		case MATH_ASIN: {
255 
256 			VALIDATE_ARG_NUM(0);
257 			*r_return = Math::asin((double)*p_inputs[0]);
258 		} break;
259 		case MATH_ACOS: {
260 
261 			VALIDATE_ARG_NUM(0);
262 			*r_return = Math::acos((double)*p_inputs[0]);
263 		} break;
264 		case MATH_ATAN: {
265 
266 			VALIDATE_ARG_NUM(0);
267 			*r_return = Math::atan((double)*p_inputs[0]);
268 		} break;
269 		case MATH_ATAN2: {
270 
271 			VALIDATE_ARG_NUM(0);
272 			VALIDATE_ARG_NUM(1);
273 			*r_return = Math::atan2((double)*p_inputs[0], (double)*p_inputs[1]);
274 		} break;
275 		case MATH_SQRT: {
276 
277 			VALIDATE_ARG_NUM(0);
278 			*r_return = Math::sqrt((double)*p_inputs[0]);
279 		} break;
280 		case MATH_FMOD: {
281 
282 			VALIDATE_ARG_NUM(0);
283 			VALIDATE_ARG_NUM(1);
284 			*r_return = Math::fmod((double)*p_inputs[0], (double)*p_inputs[1]);
285 		} break;
286 		case MATH_FPOSMOD: {
287 
288 			VALIDATE_ARG_NUM(0);
289 			VALIDATE_ARG_NUM(1);
290 			*r_return = Math::fposmod((double)*p_inputs[0], (double)*p_inputs[1]);
291 		} break;
292 		case MATH_POSMOD: {
293 
294 			VALIDATE_ARG_NUM(0);
295 			VALIDATE_ARG_NUM(1);
296 			*r_return = Math::posmod((int)*p_inputs[0], (int)*p_inputs[1]);
297 		} break;
298 		case MATH_FLOOR: {
299 
300 			VALIDATE_ARG_NUM(0);
301 			*r_return = Math::floor((double)*p_inputs[0]);
302 		} break;
303 		case MATH_CEIL: {
304 
305 			VALIDATE_ARG_NUM(0);
306 			*r_return = Math::ceil((double)*p_inputs[0]);
307 		} break;
308 		case MATH_ROUND: {
309 
310 			VALIDATE_ARG_NUM(0);
311 			*r_return = Math::round((double)*p_inputs[0]);
312 		} break;
313 		case MATH_ABS: {
314 
315 			if (p_inputs[0]->get_type() == Variant::INT) {
316 
317 				int64_t i = *p_inputs[0];
318 				*r_return = ABS(i);
319 			} else if (p_inputs[0]->get_type() == Variant::REAL) {
320 
321 				real_t r = *p_inputs[0];
322 				*r_return = Math::abs(r);
323 			} else {
324 
325 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
326 				r_error.argument = 0;
327 				r_error.expected = Variant::REAL;
328 			}
329 		} break;
330 		case MATH_SIGN: {
331 
332 			if (p_inputs[0]->get_type() == Variant::INT) {
333 
334 				int64_t i = *p_inputs[0];
335 				*r_return = i < 0 ? -1 : (i > 0 ? +1 : 0);
336 			} else if (p_inputs[0]->get_type() == Variant::REAL) {
337 
338 				real_t r = *p_inputs[0];
339 				*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
340 			} else {
341 
342 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
343 				r_error.argument = 0;
344 				r_error.expected = Variant::REAL;
345 			}
346 		} break;
347 		case MATH_POW: {
348 
349 			VALIDATE_ARG_NUM(0);
350 			VALIDATE_ARG_NUM(1);
351 			*r_return = Math::pow((double)*p_inputs[0], (double)*p_inputs[1]);
352 		} break;
353 		case MATH_LOG: {
354 
355 			VALIDATE_ARG_NUM(0);
356 			*r_return = Math::log((double)*p_inputs[0]);
357 		} break;
358 		case MATH_EXP: {
359 
360 			VALIDATE_ARG_NUM(0);
361 			*r_return = Math::exp((double)*p_inputs[0]);
362 		} break;
363 		case MATH_ISNAN: {
364 
365 			VALIDATE_ARG_NUM(0);
366 			*r_return = Math::is_nan((double)*p_inputs[0]);
367 		} break;
368 		case MATH_ISINF: {
369 
370 			VALIDATE_ARG_NUM(0);
371 			*r_return = Math::is_inf((double)*p_inputs[0]);
372 		} break;
373 		case MATH_EASE: {
374 
375 			VALIDATE_ARG_NUM(0);
376 			VALIDATE_ARG_NUM(1);
377 			*r_return = Math::ease((double)*p_inputs[0], (double)*p_inputs[1]);
378 		} break;
379 		case MATH_DECIMALS: {
380 
381 			VALIDATE_ARG_NUM(0);
382 			*r_return = Math::step_decimals((double)*p_inputs[0]);
383 		} break;
384 		case MATH_STEP_DECIMALS: {
385 
386 			VALIDATE_ARG_NUM(0);
387 			*r_return = Math::step_decimals((double)*p_inputs[0]);
388 		} break;
389 		case MATH_STEPIFY: {
390 
391 			VALIDATE_ARG_NUM(0);
392 			VALIDATE_ARG_NUM(1);
393 			*r_return = Math::stepify((double)*p_inputs[0], (double)*p_inputs[1]);
394 		} break;
395 		case MATH_LERP: {
396 
397 			VALIDATE_ARG_NUM(0);
398 			VALIDATE_ARG_NUM(1);
399 			VALIDATE_ARG_NUM(2);
400 			*r_return = Math::lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
401 		} break;
402 		case MATH_LERP_ANGLE: {
403 
404 			VALIDATE_ARG_NUM(0);
405 			VALIDATE_ARG_NUM(1);
406 			VALIDATE_ARG_NUM(2);
407 			*r_return = Math::lerp_angle((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
408 		} break;
409 		case MATH_INVERSE_LERP: {
410 
411 			VALIDATE_ARG_NUM(0);
412 			VALIDATE_ARG_NUM(1);
413 			VALIDATE_ARG_NUM(2);
414 			*r_return = Math::inverse_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
415 		} break;
416 		case MATH_RANGE_LERP: {
417 
418 			VALIDATE_ARG_NUM(0);
419 			VALIDATE_ARG_NUM(1);
420 			VALIDATE_ARG_NUM(2);
421 			VALIDATE_ARG_NUM(3);
422 			VALIDATE_ARG_NUM(4);
423 			*r_return = Math::range_lerp((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2], (double)*p_inputs[3], (double)*p_inputs[4]);
424 		} break;
425 		case MATH_SMOOTHSTEP: {
426 			VALIDATE_ARG_NUM(0);
427 			VALIDATE_ARG_NUM(1);
428 			VALIDATE_ARG_NUM(2);
429 			*r_return = Math::smoothstep((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
430 		} break;
431 		case MATH_MOVE_TOWARD: {
432 
433 			VALIDATE_ARG_NUM(0);
434 			VALIDATE_ARG_NUM(1);
435 			VALIDATE_ARG_NUM(2);
436 			*r_return = Math::move_toward((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
437 		} break;
438 		case MATH_DECTIME: {
439 
440 			VALIDATE_ARG_NUM(0);
441 			VALIDATE_ARG_NUM(1);
442 			VALIDATE_ARG_NUM(2);
443 			*r_return = Math::dectime((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
444 		} break;
445 		case MATH_RANDOMIZE: {
446 			Math::randomize();
447 
448 		} break;
449 		case MATH_RAND: {
450 			*r_return = Math::rand();
451 		} break;
452 		case MATH_RANDF: {
453 			*r_return = Math::randf();
454 		} break;
455 		case MATH_RANDOM: {
456 
457 			VALIDATE_ARG_NUM(0);
458 			VALIDATE_ARG_NUM(1);
459 			*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
460 		} break;
461 		case MATH_SEED: {
462 
463 			VALIDATE_ARG_NUM(0);
464 			uint64_t seed = *p_inputs[0];
465 			Math::seed(seed);
466 
467 		} break;
468 		case MATH_RANDSEED: {
469 
470 			VALIDATE_ARG_NUM(0);
471 			uint64_t seed = *p_inputs[0];
472 			int ret = Math::rand_from_seed(&seed);
473 			Array reta;
474 			reta.push_back(ret);
475 			reta.push_back(seed);
476 			*r_return = reta;
477 
478 		} break;
479 		case MATH_DEG2RAD: {
480 
481 			VALIDATE_ARG_NUM(0);
482 			*r_return = Math::deg2rad((double)*p_inputs[0]);
483 		} break;
484 		case MATH_RAD2DEG: {
485 
486 			VALIDATE_ARG_NUM(0);
487 			*r_return = Math::rad2deg((double)*p_inputs[0]);
488 		} break;
489 		case MATH_LINEAR2DB: {
490 
491 			VALIDATE_ARG_NUM(0);
492 			*r_return = Math::linear2db((double)*p_inputs[0]);
493 		} break;
494 		case MATH_DB2LINEAR: {
495 
496 			VALIDATE_ARG_NUM(0);
497 			*r_return = Math::db2linear((double)*p_inputs[0]);
498 		} break;
499 		case MATH_POLAR2CARTESIAN: {
500 			VALIDATE_ARG_NUM(0);
501 			VALIDATE_ARG_NUM(1);
502 			double r = *p_inputs[0];
503 			double th = *p_inputs[1];
504 			*r_return = Vector2(r * Math::cos(th), r * Math::sin(th));
505 		} break;
506 		case MATH_CARTESIAN2POLAR: {
507 			VALIDATE_ARG_NUM(0);
508 			VALIDATE_ARG_NUM(1);
509 			double x = *p_inputs[0];
510 			double y = *p_inputs[1];
511 			*r_return = Vector2(Math::sqrt(x * x + y * y), Math::atan2(y, x));
512 		} break;
513 		case MATH_WRAP: {
514 			VALIDATE_ARG_NUM(0);
515 			VALIDATE_ARG_NUM(1);
516 			VALIDATE_ARG_NUM(2);
517 			*r_return = Math::wrapi((int64_t)*p_inputs[0], (int64_t)*p_inputs[1], (int64_t)*p_inputs[2]);
518 		} break;
519 		case MATH_WRAPF: {
520 			VALIDATE_ARG_NUM(0);
521 			VALIDATE_ARG_NUM(1);
522 			VALIDATE_ARG_NUM(2);
523 			*r_return = Math::wrapf((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
524 		} break;
525 		case LOGIC_MAX: {
526 
527 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
528 
529 				int64_t a = *p_inputs[0];
530 				int64_t b = *p_inputs[1];
531 				*r_return = MAX(a, b);
532 			} else {
533 				VALIDATE_ARG_NUM(0);
534 				VALIDATE_ARG_NUM(1);
535 
536 				real_t a = *p_inputs[0];
537 				real_t b = *p_inputs[1];
538 
539 				*r_return = MAX(a, b);
540 			}
541 
542 		} break;
543 		case LOGIC_MIN: {
544 
545 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT) {
546 
547 				int64_t a = *p_inputs[0];
548 				int64_t b = *p_inputs[1];
549 				*r_return = MIN(a, b);
550 			} else {
551 				VALIDATE_ARG_NUM(0);
552 				VALIDATE_ARG_NUM(1);
553 
554 				real_t a = *p_inputs[0];
555 				real_t b = *p_inputs[1];
556 
557 				*r_return = MIN(a, b);
558 			}
559 		} break;
560 		case LOGIC_CLAMP: {
561 
562 			if (p_inputs[0]->get_type() == Variant::INT && p_inputs[1]->get_type() == Variant::INT && p_inputs[2]->get_type() == Variant::INT) {
563 
564 				int64_t a = *p_inputs[0];
565 				int64_t b = *p_inputs[1];
566 				int64_t c = *p_inputs[2];
567 				*r_return = CLAMP(a, b, c);
568 			} else {
569 				VALIDATE_ARG_NUM(0);
570 				VALIDATE_ARG_NUM(1);
571 				VALIDATE_ARG_NUM(2);
572 
573 				real_t a = *p_inputs[0];
574 				real_t b = *p_inputs[1];
575 				real_t c = *p_inputs[2];
576 
577 				*r_return = CLAMP(a, b, c);
578 			}
579 		} break;
580 		case LOGIC_NEAREST_PO2: {
581 
582 			VALIDATE_ARG_NUM(0);
583 			int64_t num = *p_inputs[0];
584 			*r_return = next_power_of_2(num);
585 		} break;
586 		case OBJ_WEAKREF: {
587 
588 			if (p_inputs[0]->get_type() != Variant::OBJECT) {
589 
590 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
591 				r_error.argument = 0;
592 				r_error.expected = Variant::OBJECT;
593 
594 				return;
595 			}
596 
597 			if (p_inputs[0]->is_ref()) {
598 
599 				REF r = *p_inputs[0];
600 				if (!r.is_valid()) {
601 
602 					return;
603 				}
604 
605 				Ref<WeakRef> wref = memnew(WeakRef);
606 				wref->set_ref(r);
607 				*r_return = wref;
608 			} else {
609 				Object *obj = *p_inputs[0];
610 				if (!obj) {
611 
612 					return;
613 				}
614 				Ref<WeakRef> wref = memnew(WeakRef);
615 				wref->set_obj(obj);
616 				*r_return = wref;
617 			}
618 
619 		} break;
620 		case FUNC_FUNCREF: {
621 
622 			if (p_inputs[0]->get_type() != Variant::OBJECT) {
623 
624 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
625 				r_error.argument = 0;
626 				r_error.expected = Variant::OBJECT;
627 
628 				return;
629 			}
630 			if (p_inputs[1]->get_type() != Variant::STRING && p_inputs[1]->get_type() != Variant::NODE_PATH) {
631 
632 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
633 				r_error.argument = 1;
634 				r_error.expected = Variant::STRING;
635 
636 				return;
637 			}
638 
639 			Ref<FuncRef> fr = memnew(FuncRef);
640 
641 			fr->set_instance(*p_inputs[0]);
642 			fr->set_function(*p_inputs[1]);
643 
644 			*r_return = fr;
645 
646 		} break;
647 		case TYPE_CONVERT: {
648 
649 			VALIDATE_ARG_NUM(1);
650 			int type = *p_inputs[1];
651 			if (type < 0 || type >= Variant::VARIANT_MAX) {
652 
653 				r_error_str = RTR("Invalid type argument to convert(), use TYPE_* constants.");
654 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
655 				r_error.argument = 0;
656 				r_error.expected = Variant::INT;
657 				return;
658 
659 			} else {
660 
661 				*r_return = Variant::construct(Variant::Type(type), p_inputs, 1, r_error);
662 			}
663 		} break;
664 		case TYPE_OF: {
665 
666 			*r_return = p_inputs[0]->get_type();
667 
668 		} break;
669 		case TYPE_EXISTS: {
670 
671 			*r_return = ClassDB::class_exists(*p_inputs[0]);
672 
673 		} break;
674 		case TEXT_CHAR: {
675 
676 			CharType result[2] = { *p_inputs[0], 0 };
677 
678 			*r_return = String(result);
679 
680 		} break;
681 		case TEXT_ORD: {
682 
683 			if (p_inputs[0]->get_type() != Variant::STRING) {
684 
685 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
686 				r_error.argument = 0;
687 				r_error.expected = Variant::STRING;
688 
689 				return;
690 			}
691 
692 			String str = *p_inputs[0];
693 
694 			if (str.length() != 1) {
695 
696 				r_error_str = RTR("Expected a string of length 1 (a character).");
697 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
698 				r_error.argument = 0;
699 				r_error.expected = Variant::STRING;
700 
701 				return;
702 			}
703 
704 			*r_return = str.get(0);
705 
706 		} break;
707 		case TEXT_STR: {
708 
709 			String str = *p_inputs[0];
710 
711 			*r_return = str;
712 
713 		} break;
714 		case TEXT_PRINT: {
715 
716 			String str = *p_inputs[0];
717 			print_line(str);
718 
719 		} break;
720 
721 		case TEXT_PRINTERR: {
722 
723 			String str = *p_inputs[0];
724 			print_error(str);
725 
726 		} break;
727 		case TEXT_PRINTRAW: {
728 
729 			String str = *p_inputs[0];
730 			OS::get_singleton()->print("%s", str.utf8().get_data());
731 
732 		} break;
733 		case VAR_TO_STR: {
734 
735 			String vars;
736 			VariantWriter::write_to_string(*p_inputs[0], vars);
737 			*r_return = vars;
738 		} break;
739 		case STR_TO_VAR: {
740 
741 			if (p_inputs[0]->get_type() != Variant::STRING) {
742 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
743 				r_error.argument = 0;
744 				r_error.expected = Variant::STRING;
745 
746 				return;
747 			}
748 
749 			VariantParser::StreamString ss;
750 			ss.s = *p_inputs[0];
751 
752 			String errs;
753 			int line;
754 			Error err = VariantParser::parse(&ss, *r_return, errs, line);
755 
756 			if (err != OK) {
757 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
758 				r_error.argument = 0;
759 				r_error.expected = Variant::STRING;
760 				*r_return = "Parse error at line " + itos(line) + ": " + errs;
761 				return;
762 			}
763 
764 		} break;
765 		case VAR_TO_BYTES: {
766 
767 			PoolByteArray barr;
768 			bool full_objects = *p_inputs[1];
769 			int len;
770 			Error err = encode_variant(*p_inputs[0], NULL, len, full_objects);
771 			if (err) {
772 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
773 				r_error.argument = 0;
774 				r_error.expected = Variant::NIL;
775 				r_error_str = "Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID).";
776 				return;
777 			}
778 
779 			barr.resize(len);
780 			{
781 				PoolByteArray::Write w = barr.write();
782 				encode_variant(*p_inputs[0], w.ptr(), len, full_objects);
783 			}
784 			*r_return = barr;
785 		} break;
786 		case BYTES_TO_VAR: {
787 
788 			if (p_inputs[0]->get_type() != Variant::POOL_BYTE_ARRAY) {
789 				r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
790 				r_error.argument = 0;
791 				r_error.expected = Variant::POOL_BYTE_ARRAY;
792 
793 				return;
794 			}
795 
796 			PoolByteArray varr = *p_inputs[0];
797 			bool allow_objects = *p_inputs[1];
798 			Variant ret;
799 			{
800 				PoolByteArray::Read r = varr.read();
801 				Error err = decode_variant(ret, r.ptr(), varr.size(), NULL, allow_objects);
802 				if (err != OK) {
803 					r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
804 					r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
805 					r_error.argument = 0;
806 					r_error.expected = Variant::POOL_BYTE_ARRAY;
807 					return;
808 				}
809 			}
810 
811 			*r_return = ret;
812 
813 		} break;
814 		case COLORN: {
815 
816 			VALIDATE_ARG_NUM(1);
817 
818 			Color color = Color::named(*p_inputs[0]);
819 			color.a = *p_inputs[1];
820 
821 			*r_return = String(color);
822 
823 		} break;
824 		default: {
825 		}
826 	}
827 }
828 
829 ////////
830 
_is_number(CharType c)831 static bool _is_number(CharType c) {
832 	return (c >= '0' && c <= '9');
833 }
834 
_get_token(Token & r_token)835 Error Expression::_get_token(Token &r_token) {
836 
837 	while (true) {
838 #define GET_CHAR() (str_ofs >= expression.length() ? 0 : expression[str_ofs++])
839 
840 		CharType cchar = GET_CHAR();
841 
842 		switch (cchar) {
843 
844 			case 0: {
845 				r_token.type = TK_EOF;
846 				return OK;
847 			};
848 			case '{': {
849 
850 				r_token.type = TK_CURLY_BRACKET_OPEN;
851 				return OK;
852 			};
853 			case '}': {
854 
855 				r_token.type = TK_CURLY_BRACKET_CLOSE;
856 				return OK;
857 			};
858 			case '[': {
859 
860 				r_token.type = TK_BRACKET_OPEN;
861 				return OK;
862 			};
863 			case ']': {
864 
865 				r_token.type = TK_BRACKET_CLOSE;
866 				return OK;
867 			};
868 			case '(': {
869 
870 				r_token.type = TK_PARENTHESIS_OPEN;
871 				return OK;
872 			};
873 			case ')': {
874 
875 				r_token.type = TK_PARENTHESIS_CLOSE;
876 				return OK;
877 			};
878 			case ',': {
879 
880 				r_token.type = TK_COMMA;
881 				return OK;
882 			};
883 			case ':': {
884 
885 				r_token.type = TK_COLON;
886 				return OK;
887 			};
888 			case '$': {
889 
890 				r_token.type = TK_INPUT;
891 				int index = 0;
892 				do {
893 					if (!_is_number(expression[str_ofs])) {
894 						_set_error("Expected number after '$'");
895 						r_token.type = TK_ERROR;
896 						return ERR_PARSE_ERROR;
897 					}
898 					index *= 10;
899 					index += expression[str_ofs] - '0';
900 					str_ofs++;
901 
902 				} while (_is_number(expression[str_ofs]));
903 
904 				r_token.value = index;
905 				return OK;
906 			};
907 			case '=': {
908 
909 				cchar = GET_CHAR();
910 				if (cchar == '=') {
911 					r_token.type = TK_OP_EQUAL;
912 				} else {
913 					_set_error("Expected '='");
914 					r_token.type = TK_ERROR;
915 					return ERR_PARSE_ERROR;
916 				}
917 				return OK;
918 			};
919 			case '!': {
920 
921 				if (expression[str_ofs] == '=') {
922 					r_token.type = TK_OP_NOT_EQUAL;
923 					str_ofs++;
924 				} else {
925 					r_token.type = TK_OP_NOT;
926 				}
927 				return OK;
928 			};
929 			case '>': {
930 
931 				if (expression[str_ofs] == '=') {
932 					r_token.type = TK_OP_GREATER_EQUAL;
933 					str_ofs++;
934 				} else if (expression[str_ofs] == '>') {
935 					r_token.type = TK_OP_SHIFT_RIGHT;
936 					str_ofs++;
937 				} else {
938 					r_token.type = TK_OP_GREATER;
939 				}
940 				return OK;
941 			};
942 			case '<': {
943 
944 				if (expression[str_ofs] == '=') {
945 					r_token.type = TK_OP_LESS_EQUAL;
946 					str_ofs++;
947 				} else if (expression[str_ofs] == '<') {
948 					r_token.type = TK_OP_SHIFT_LEFT;
949 					str_ofs++;
950 				} else {
951 					r_token.type = TK_OP_LESS;
952 				}
953 				return OK;
954 			};
955 			case '+': {
956 				r_token.type = TK_OP_ADD;
957 				return OK;
958 			};
959 			case '-': {
960 				r_token.type = TK_OP_SUB;
961 				return OK;
962 			};
963 			case '/': {
964 				r_token.type = TK_OP_DIV;
965 				return OK;
966 			};
967 			case '*': {
968 				r_token.type = TK_OP_MUL;
969 				return OK;
970 			};
971 			case '%': {
972 				r_token.type = TK_OP_MOD;
973 				return OK;
974 			};
975 			case '&': {
976 
977 				if (expression[str_ofs] == '&') {
978 					r_token.type = TK_OP_AND;
979 					str_ofs++;
980 				} else {
981 					r_token.type = TK_OP_BIT_AND;
982 				}
983 				return OK;
984 			};
985 			case '|': {
986 
987 				if (expression[str_ofs] == '|') {
988 					r_token.type = TK_OP_OR;
989 					str_ofs++;
990 				} else {
991 					r_token.type = TK_OP_BIT_OR;
992 				}
993 				return OK;
994 			};
995 			case '^': {
996 
997 				r_token.type = TK_OP_BIT_XOR;
998 
999 				return OK;
1000 			};
1001 			case '~': {
1002 
1003 				r_token.type = TK_OP_BIT_INVERT;
1004 
1005 				return OK;
1006 			};
1007 			case '\'':
1008 			case '"': {
1009 
1010 				String str;
1011 				while (true) {
1012 
1013 					CharType ch = GET_CHAR();
1014 
1015 					if (ch == 0) {
1016 						_set_error("Unterminated String");
1017 						r_token.type = TK_ERROR;
1018 						return ERR_PARSE_ERROR;
1019 					} else if (ch == cchar) {
1020 						// cchar contain a corresponding quote symbol
1021 						break;
1022 					} else if (ch == '\\') {
1023 						//escaped characters...
1024 
1025 						CharType next = GET_CHAR();
1026 						if (next == 0) {
1027 							_set_error("Unterminated String");
1028 							r_token.type = TK_ERROR;
1029 							return ERR_PARSE_ERROR;
1030 						}
1031 						CharType res = 0;
1032 
1033 						switch (next) {
1034 
1035 							case 'b': res = 8; break;
1036 							case 't': res = 9; break;
1037 							case 'n': res = 10; break;
1038 							case 'f': res = 12; break;
1039 							case 'r': res = 13; break;
1040 							case 'u': {
1041 								//hexnumbarh - oct is deprecated
1042 
1043 								for (int j = 0; j < 4; j++) {
1044 									CharType c = GET_CHAR();
1045 
1046 									if (c == 0) {
1047 										_set_error("Unterminated String");
1048 										r_token.type = TK_ERROR;
1049 										return ERR_PARSE_ERROR;
1050 									}
1051 									if (!(_is_number(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
1052 
1053 										_set_error("Malformed hex constant in string");
1054 										r_token.type = TK_ERROR;
1055 										return ERR_PARSE_ERROR;
1056 									}
1057 									CharType v;
1058 									if (_is_number(c)) {
1059 										v = c - '0';
1060 									} else if (c >= 'a' && c <= 'f') {
1061 										v = c - 'a';
1062 										v += 10;
1063 									} else if (c >= 'A' && c <= 'F') {
1064 										v = c - 'A';
1065 										v += 10;
1066 									} else {
1067 										ERR_PRINT("BUG");
1068 										v = 0;
1069 									}
1070 
1071 									res <<= 4;
1072 									res |= v;
1073 								}
1074 
1075 							} break;
1076 							//case '\"': res='\"'; break;
1077 							//case '\\': res='\\'; break;
1078 							//case '/': res='/'; break;
1079 							default: {
1080 								res = next;
1081 								//r_err_str="Invalid escape sequence";
1082 								//return ERR_PARSE_ERROR;
1083 							} break;
1084 						}
1085 
1086 						str += res;
1087 
1088 					} else {
1089 						str += ch;
1090 					}
1091 				}
1092 
1093 				r_token.type = TK_CONSTANT;
1094 				r_token.value = str;
1095 				return OK;
1096 
1097 			} break;
1098 			default: {
1099 
1100 				if (cchar <= 32) {
1101 					break;
1102 				}
1103 
1104 				CharType next_char = (str_ofs >= expression.length()) ? 0 : expression[str_ofs];
1105 				if (_is_number(cchar) || (cchar == '.' && _is_number(next_char))) {
1106 					//a number
1107 
1108 					String num;
1109 #define READING_SIGN 0
1110 #define READING_INT 1
1111 #define READING_DEC 2
1112 #define READING_EXP 3
1113 #define READING_DONE 4
1114 					int reading = READING_INT;
1115 
1116 					CharType c = cchar;
1117 					bool exp_sign = false;
1118 					bool exp_beg = false;
1119 					bool is_float = false;
1120 
1121 					while (true) {
1122 
1123 						switch (reading) {
1124 							case READING_INT: {
1125 
1126 								if (_is_number(c)) {
1127 									//pass
1128 								} else if (c == '.') {
1129 									reading = READING_DEC;
1130 									is_float = true;
1131 								} else if (c == 'e') {
1132 									reading = READING_EXP;
1133 								} else {
1134 									reading = READING_DONE;
1135 								}
1136 
1137 							} break;
1138 							case READING_DEC: {
1139 
1140 								if (_is_number(c)) {
1141 
1142 								} else if (c == 'e') {
1143 									reading = READING_EXP;
1144 
1145 								} else {
1146 									reading = READING_DONE;
1147 								}
1148 
1149 							} break;
1150 							case READING_EXP: {
1151 
1152 								if (_is_number(c)) {
1153 									exp_beg = true;
1154 
1155 								} else if ((c == '-' || c == '+') && !exp_sign && !exp_beg) {
1156 									if (c == '-')
1157 										is_float = true;
1158 									exp_sign = true;
1159 
1160 								} else {
1161 									reading = READING_DONE;
1162 								}
1163 							} break;
1164 						}
1165 
1166 						if (reading == READING_DONE)
1167 							break;
1168 						num += String::chr(c);
1169 						c = GET_CHAR();
1170 					}
1171 
1172 					str_ofs--;
1173 
1174 					r_token.type = TK_CONSTANT;
1175 
1176 					if (is_float)
1177 						r_token.value = num.to_double();
1178 					else
1179 						r_token.value = num.to_int64();
1180 					return OK;
1181 
1182 				} else if ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_') {
1183 
1184 					String id;
1185 					bool first = true;
1186 
1187 					while ((cchar >= 'A' && cchar <= 'Z') || (cchar >= 'a' && cchar <= 'z') || cchar == '_' || (!first && _is_number(cchar))) {
1188 
1189 						id += String::chr(cchar);
1190 						cchar = GET_CHAR();
1191 						first = false;
1192 					}
1193 
1194 					str_ofs--; //go back one
1195 
1196 					if (id == "in") {
1197 						r_token.type = TK_OP_IN;
1198 					} else if (id == "null") {
1199 						r_token.type = TK_CONSTANT;
1200 						r_token.value = Variant();
1201 					} else if (id == "true") {
1202 						r_token.type = TK_CONSTANT;
1203 						r_token.value = true;
1204 					} else if (id == "false") {
1205 						r_token.type = TK_CONSTANT;
1206 						r_token.value = false;
1207 					} else if (id == "PI") {
1208 						r_token.type = TK_CONSTANT;
1209 						r_token.value = Math_PI;
1210 					} else if (id == "TAU") {
1211 						r_token.type = TK_CONSTANT;
1212 						r_token.value = Math_TAU;
1213 					} else if (id == "INF") {
1214 						r_token.type = TK_CONSTANT;
1215 						r_token.value = Math_INF;
1216 					} else if (id == "NAN") {
1217 						r_token.type = TK_CONSTANT;
1218 						r_token.value = Math_NAN;
1219 					} else if (id == "not") {
1220 						r_token.type = TK_OP_NOT;
1221 					} else if (id == "or") {
1222 						r_token.type = TK_OP_OR;
1223 					} else if (id == "and") {
1224 						r_token.type = TK_OP_AND;
1225 					} else if (id == "self") {
1226 						r_token.type = TK_SELF;
1227 					} else {
1228 
1229 						for (int i = 0; i < Variant::VARIANT_MAX; i++) {
1230 							if (id == Variant::get_type_name(Variant::Type(i))) {
1231 								r_token.type = TK_BASIC_TYPE;
1232 								r_token.value = i;
1233 								return OK;
1234 							}
1235 						}
1236 
1237 						BuiltinFunc bifunc = find_function(id);
1238 						if (bifunc != FUNC_MAX) {
1239 							r_token.type = TK_BUILTIN_FUNC;
1240 							r_token.value = bifunc;
1241 							return OK;
1242 						}
1243 
1244 						r_token.type = TK_IDENTIFIER;
1245 						r_token.value = id;
1246 					}
1247 
1248 					return OK;
1249 
1250 				} else if (cchar == '.') {
1251 					// Handled down there as we support '.[0-9]' as numbers above
1252 					r_token.type = TK_PERIOD;
1253 					return OK;
1254 
1255 				} else {
1256 					_set_error("Unexpected character.");
1257 					r_token.type = TK_ERROR;
1258 					return ERR_PARSE_ERROR;
1259 				}
1260 			}
1261 		}
1262 #undef GET_CHAR
1263 	}
1264 
1265 	r_token.type = TK_ERROR;
1266 	return ERR_PARSE_ERROR;
1267 }
1268 
1269 const char *Expression::token_name[TK_MAX] = {
1270 	"CURLY BRACKET OPEN",
1271 	"CURLY BRACKET CLOSE",
1272 	"BRACKET OPEN",
1273 	"BRACKET CLOSE",
1274 	"PARENTHESIS OPEN",
1275 	"PARENTHESIS CLOSE",
1276 	"IDENTIFIER",
1277 	"BUILTIN FUNC",
1278 	"SELF",
1279 	"CONSTANT",
1280 	"BASIC TYPE",
1281 	"COLON",
1282 	"COMMA",
1283 	"PERIOD",
1284 	"OP IN",
1285 	"OP EQUAL",
1286 	"OP NOT EQUAL",
1287 	"OP LESS",
1288 	"OP LESS EQUAL",
1289 	"OP GREATER",
1290 	"OP GREATER EQUAL",
1291 	"OP AND",
1292 	"OP OR",
1293 	"OP NOT",
1294 	"OP ADD",
1295 	"OP SUB",
1296 	"OP MUL",
1297 	"OP DIV",
1298 	"OP MOD",
1299 	"OP SHIFT LEFT",
1300 	"OP SHIFT RIGHT",
1301 	"OP BIT AND",
1302 	"OP BIT OR",
1303 	"OP BIT XOR",
1304 	"OP BIT INVERT",
1305 	"OP INPUT",
1306 	"EOF",
1307 	"ERROR"
1308 };
1309 
_parse_expression()1310 Expression::ENode *Expression::_parse_expression() {
1311 
1312 	Vector<ExpressionNode> expression;
1313 
1314 	while (true) {
1315 		//keep appending stuff to expression
1316 		ENode *expr = NULL;
1317 
1318 		Token tk;
1319 		_get_token(tk);
1320 		if (error_set)
1321 			return NULL;
1322 
1323 		switch (tk.type) {
1324 			case TK_CURLY_BRACKET_OPEN: {
1325 				//a dictionary
1326 				DictionaryNode *dn = alloc_node<DictionaryNode>();
1327 
1328 				while (true) {
1329 
1330 					int cofs = str_ofs;
1331 					_get_token(tk);
1332 					if (tk.type == TK_CURLY_BRACKET_CLOSE) {
1333 						break;
1334 					}
1335 					str_ofs = cofs; //revert
1336 					//parse an expression
1337 					ENode *subexpr = _parse_expression();
1338 					if (!subexpr)
1339 						return NULL;
1340 					dn->dict.push_back(subexpr);
1341 
1342 					_get_token(tk);
1343 					if (tk.type != TK_COLON) {
1344 						_set_error("Expected ':'");
1345 						return NULL;
1346 					}
1347 
1348 					subexpr = _parse_expression();
1349 					if (!subexpr)
1350 						return NULL;
1351 
1352 					dn->dict.push_back(subexpr);
1353 
1354 					cofs = str_ofs;
1355 					_get_token(tk);
1356 					if (tk.type == TK_COMMA) {
1357 						//all good
1358 					} else if (tk.type == TK_CURLY_BRACKET_CLOSE) {
1359 						str_ofs = cofs;
1360 					} else {
1361 						_set_error("Expected ',' or '}'");
1362 					}
1363 				}
1364 
1365 				expr = dn;
1366 			} break;
1367 			case TK_BRACKET_OPEN: {
1368 				//an array
1369 
1370 				ArrayNode *an = alloc_node<ArrayNode>();
1371 
1372 				while (true) {
1373 
1374 					int cofs = str_ofs;
1375 					_get_token(tk);
1376 					if (tk.type == TK_BRACKET_CLOSE) {
1377 						break;
1378 					}
1379 					str_ofs = cofs; //revert
1380 					//parse an expression
1381 					ENode *subexpr = _parse_expression();
1382 					if (!subexpr)
1383 						return NULL;
1384 					an->array.push_back(subexpr);
1385 
1386 					cofs = str_ofs;
1387 					_get_token(tk);
1388 					if (tk.type == TK_COMMA) {
1389 						//all good
1390 					} else if (tk.type == TK_BRACKET_CLOSE) {
1391 						str_ofs = cofs;
1392 					} else {
1393 						_set_error("Expected ',' or ']'");
1394 					}
1395 				}
1396 
1397 				expr = an;
1398 			} break;
1399 			case TK_PARENTHESIS_OPEN: {
1400 				//a suexpression
1401 				ENode *e = _parse_expression();
1402 				if (error_set)
1403 					return NULL;
1404 				_get_token(tk);
1405 				if (tk.type != TK_PARENTHESIS_CLOSE) {
1406 					_set_error("Expected ')'");
1407 					return NULL;
1408 				}
1409 
1410 				expr = e;
1411 
1412 			} break;
1413 			case TK_IDENTIFIER: {
1414 
1415 				String identifier = tk.value;
1416 
1417 				int cofs = str_ofs;
1418 				_get_token(tk);
1419 				if (tk.type == TK_PARENTHESIS_OPEN) {
1420 					//function call
1421 					CallNode *func_call = alloc_node<CallNode>();
1422 					func_call->method = identifier;
1423 					SelfNode *self_node = alloc_node<SelfNode>();
1424 					func_call->base = self_node;
1425 
1426 					while (true) {
1427 
1428 						int cofs2 = str_ofs;
1429 						_get_token(tk);
1430 						if (tk.type == TK_PARENTHESIS_CLOSE) {
1431 							break;
1432 						}
1433 						str_ofs = cofs2; //revert
1434 						//parse an expression
1435 						ENode *subexpr = _parse_expression();
1436 						if (!subexpr)
1437 							return NULL;
1438 
1439 						func_call->arguments.push_back(subexpr);
1440 
1441 						cofs2 = str_ofs;
1442 						_get_token(tk);
1443 						if (tk.type == TK_COMMA) {
1444 							//all good
1445 						} else if (tk.type == TK_PARENTHESIS_CLOSE) {
1446 							str_ofs = cofs2;
1447 						} else {
1448 							_set_error("Expected ',' or ')'");
1449 						}
1450 					}
1451 
1452 					expr = func_call;
1453 				} else {
1454 					//named indexing
1455 					str_ofs = cofs;
1456 
1457 					int input_index = -1;
1458 					for (int i = 0; i < input_names.size(); i++) {
1459 						if (input_names[i] == identifier) {
1460 							input_index = i;
1461 							break;
1462 						}
1463 					}
1464 
1465 					if (input_index != -1) {
1466 						InputNode *input = alloc_node<InputNode>();
1467 						input->index = input_index;
1468 						expr = input;
1469 					} else {
1470 
1471 						NamedIndexNode *index = alloc_node<NamedIndexNode>();
1472 						SelfNode *self_node = alloc_node<SelfNode>();
1473 						index->base = self_node;
1474 						index->name = identifier;
1475 						expr = index;
1476 					}
1477 				}
1478 			} break;
1479 			case TK_INPUT: {
1480 
1481 				InputNode *input = alloc_node<InputNode>();
1482 				input->index = tk.value;
1483 				expr = input;
1484 			} break;
1485 			case TK_SELF: {
1486 
1487 				SelfNode *self = alloc_node<SelfNode>();
1488 				expr = self;
1489 			} break;
1490 			case TK_CONSTANT: {
1491 				ConstantNode *constant = alloc_node<ConstantNode>();
1492 				constant->value = tk.value;
1493 				expr = constant;
1494 			} break;
1495 			case TK_BASIC_TYPE: {
1496 				//constructor..
1497 
1498 				Variant::Type bt = Variant::Type(int(tk.value));
1499 				_get_token(tk);
1500 				if (tk.type != TK_PARENTHESIS_OPEN) {
1501 					_set_error("Expected '('");
1502 					return NULL;
1503 				}
1504 
1505 				ConstructorNode *constructor = alloc_node<ConstructorNode>();
1506 				constructor->data_type = bt;
1507 
1508 				while (true) {
1509 
1510 					int cofs = str_ofs;
1511 					_get_token(tk);
1512 					if (tk.type == TK_PARENTHESIS_CLOSE) {
1513 						break;
1514 					}
1515 					str_ofs = cofs; //revert
1516 					//parse an expression
1517 					ENode *subexpr = _parse_expression();
1518 					if (!subexpr)
1519 						return NULL;
1520 
1521 					constructor->arguments.push_back(subexpr);
1522 
1523 					cofs = str_ofs;
1524 					_get_token(tk);
1525 					if (tk.type == TK_COMMA) {
1526 						//all good
1527 					} else if (tk.type == TK_PARENTHESIS_CLOSE) {
1528 						str_ofs = cofs;
1529 					} else {
1530 						_set_error("Expected ',' or ')'");
1531 					}
1532 				}
1533 
1534 				expr = constructor;
1535 
1536 			} break;
1537 			case TK_BUILTIN_FUNC: {
1538 				//builtin function
1539 
1540 				_get_token(tk);
1541 				if (tk.type != TK_PARENTHESIS_OPEN) {
1542 					_set_error("Expected '('");
1543 					return NULL;
1544 				}
1545 
1546 				BuiltinFuncNode *bifunc = alloc_node<BuiltinFuncNode>();
1547 				bifunc->func = BuiltinFunc(int(tk.value));
1548 
1549 				while (true) {
1550 
1551 					int cofs = str_ofs;
1552 					_get_token(tk);
1553 					if (tk.type == TK_PARENTHESIS_CLOSE) {
1554 						break;
1555 					}
1556 					str_ofs = cofs; //revert
1557 					//parse an expression
1558 					ENode *subexpr = _parse_expression();
1559 					if (!subexpr)
1560 						return NULL;
1561 
1562 					bifunc->arguments.push_back(subexpr);
1563 
1564 					cofs = str_ofs;
1565 					_get_token(tk);
1566 					if (tk.type == TK_COMMA) {
1567 						//all good
1568 					} else if (tk.type == TK_PARENTHESIS_CLOSE) {
1569 						str_ofs = cofs;
1570 					} else {
1571 						_set_error("Expected ',' or ')'");
1572 					}
1573 				}
1574 
1575 				int expected_args = get_func_argument_count(bifunc->func);
1576 				if (bifunc->arguments.size() != expected_args) {
1577 					_set_error("Builtin func '" + get_func_name(bifunc->func) + "' expects " + itos(expected_args) + " arguments.");
1578 				}
1579 
1580 				expr = bifunc;
1581 
1582 			} break;
1583 			case TK_OP_SUB: {
1584 
1585 				ExpressionNode e;
1586 				e.is_op = true;
1587 				e.op = Variant::OP_NEGATE;
1588 				expression.push_back(e);
1589 				continue;
1590 			} break;
1591 			case TK_OP_NOT: {
1592 
1593 				ExpressionNode e;
1594 				e.is_op = true;
1595 				e.op = Variant::OP_NOT;
1596 				expression.push_back(e);
1597 				continue;
1598 			} break;
1599 
1600 			default: {
1601 				_set_error("Expected expression.");
1602 				return NULL;
1603 			} break;
1604 		}
1605 
1606 		//before going to operators, must check indexing!
1607 
1608 		while (true) {
1609 			int cofs2 = str_ofs;
1610 			_get_token(tk);
1611 			if (error_set)
1612 				return NULL;
1613 
1614 			bool done = false;
1615 
1616 			switch (tk.type) {
1617 				case TK_BRACKET_OPEN: {
1618 					//value indexing
1619 
1620 					IndexNode *index = alloc_node<IndexNode>();
1621 					index->base = expr;
1622 
1623 					ENode *what = _parse_expression();
1624 					if (!what)
1625 						return NULL;
1626 
1627 					index->index = what;
1628 
1629 					_get_token(tk);
1630 					if (tk.type != TK_BRACKET_CLOSE) {
1631 						_set_error("Expected ']' at end of index.");
1632 						return NULL;
1633 					}
1634 					expr = index;
1635 
1636 				} break;
1637 				case TK_PERIOD: {
1638 					//named indexing or function call
1639 					_get_token(tk);
1640 					if (tk.type != TK_IDENTIFIER) {
1641 						_set_error("Expected identifier after '.'");
1642 						return NULL;
1643 					}
1644 
1645 					StringName identifier = tk.value;
1646 
1647 					int cofs = str_ofs;
1648 					_get_token(tk);
1649 					if (tk.type == TK_PARENTHESIS_OPEN) {
1650 						//function call
1651 						CallNode *func_call = alloc_node<CallNode>();
1652 						func_call->method = identifier;
1653 						func_call->base = expr;
1654 
1655 						while (true) {
1656 
1657 							int cofs3 = str_ofs;
1658 							_get_token(tk);
1659 							if (tk.type == TK_PARENTHESIS_CLOSE) {
1660 								break;
1661 							}
1662 							str_ofs = cofs3; //revert
1663 							//parse an expression
1664 							ENode *subexpr = _parse_expression();
1665 							if (!subexpr)
1666 								return NULL;
1667 
1668 							func_call->arguments.push_back(subexpr);
1669 
1670 							cofs3 = str_ofs;
1671 							_get_token(tk);
1672 							if (tk.type == TK_COMMA) {
1673 								//all good
1674 							} else if (tk.type == TK_PARENTHESIS_CLOSE) {
1675 								str_ofs = cofs3;
1676 							} else {
1677 								_set_error("Expected ',' or ')'");
1678 							}
1679 						}
1680 
1681 						expr = func_call;
1682 					} else {
1683 						//named indexing
1684 						str_ofs = cofs;
1685 
1686 						NamedIndexNode *index = alloc_node<NamedIndexNode>();
1687 						index->base = expr;
1688 						index->name = identifier;
1689 						expr = index;
1690 					}
1691 
1692 				} break;
1693 				default: {
1694 					str_ofs = cofs2;
1695 					done = true;
1696 				} break;
1697 			}
1698 
1699 			if (done)
1700 				break;
1701 		}
1702 
1703 		//push expression
1704 		{
1705 			ExpressionNode e;
1706 			e.is_op = false;
1707 			e.node = expr;
1708 			expression.push_back(e);
1709 		}
1710 
1711 		//ok finally look for an operator
1712 
1713 		int cofs = str_ofs;
1714 		_get_token(tk);
1715 		if (error_set)
1716 			return NULL;
1717 
1718 		Variant::Operator op = Variant::OP_MAX;
1719 
1720 		switch (tk.type) {
1721 			case TK_OP_IN: op = Variant::OP_IN; break;
1722 			case TK_OP_EQUAL: op = Variant::OP_EQUAL; break;
1723 			case TK_OP_NOT_EQUAL: op = Variant::OP_NOT_EQUAL; break;
1724 			case TK_OP_LESS: op = Variant::OP_LESS; break;
1725 			case TK_OP_LESS_EQUAL: op = Variant::OP_LESS_EQUAL; break;
1726 			case TK_OP_GREATER: op = Variant::OP_GREATER; break;
1727 			case TK_OP_GREATER_EQUAL: op = Variant::OP_GREATER_EQUAL; break;
1728 			case TK_OP_AND: op = Variant::OP_AND; break;
1729 			case TK_OP_OR: op = Variant::OP_OR; break;
1730 			case TK_OP_NOT: op = Variant::OP_NOT; break;
1731 			case TK_OP_ADD: op = Variant::OP_ADD; break;
1732 			case TK_OP_SUB: op = Variant::OP_SUBTRACT; break;
1733 			case TK_OP_MUL: op = Variant::OP_MULTIPLY; break;
1734 			case TK_OP_DIV: op = Variant::OP_DIVIDE; break;
1735 			case TK_OP_MOD: op = Variant::OP_MODULE; break;
1736 			case TK_OP_SHIFT_LEFT: op = Variant::OP_SHIFT_LEFT; break;
1737 			case TK_OP_SHIFT_RIGHT: op = Variant::OP_SHIFT_RIGHT; break;
1738 			case TK_OP_BIT_AND: op = Variant::OP_BIT_AND; break;
1739 			case TK_OP_BIT_OR: op = Variant::OP_BIT_OR; break;
1740 			case TK_OP_BIT_XOR: op = Variant::OP_BIT_XOR; break;
1741 			case TK_OP_BIT_INVERT: op = Variant::OP_BIT_NEGATE; break;
1742 			default: {
1743 			};
1744 		}
1745 
1746 		if (op == Variant::OP_MAX) { //stop appending stuff
1747 			str_ofs = cofs;
1748 			break;
1749 		}
1750 
1751 		//push operator and go on
1752 		{
1753 			ExpressionNode e;
1754 			e.is_op = true;
1755 			e.op = op;
1756 			expression.push_back(e);
1757 		}
1758 	}
1759 
1760 	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
1761 
1762 	while (expression.size() > 1) {
1763 
1764 		int next_op = -1;
1765 		int min_priority = 0xFFFFF;
1766 		bool is_unary = false;
1767 
1768 		for (int i = 0; i < expression.size(); i++) {
1769 
1770 			if (!expression[i].is_op) {
1771 
1772 				continue;
1773 			}
1774 
1775 			int priority;
1776 
1777 			bool unary = false;
1778 
1779 			switch (expression[i].op) {
1780 
1781 				case Variant::OP_BIT_NEGATE:
1782 					priority = 0;
1783 					unary = true;
1784 					break;
1785 				case Variant::OP_NEGATE:
1786 					priority = 1;
1787 					unary = true;
1788 					break;
1789 
1790 				case Variant::OP_MULTIPLY: priority = 2; break;
1791 				case Variant::OP_DIVIDE: priority = 2; break;
1792 				case Variant::OP_MODULE: priority = 2; break;
1793 
1794 				case Variant::OP_ADD: priority = 3; break;
1795 				case Variant::OP_SUBTRACT: priority = 3; break;
1796 
1797 				case Variant::OP_SHIFT_LEFT: priority = 4; break;
1798 				case Variant::OP_SHIFT_RIGHT: priority = 4; break;
1799 
1800 				case Variant::OP_BIT_AND: priority = 5; break;
1801 				case Variant::OP_BIT_XOR: priority = 6; break;
1802 				case Variant::OP_BIT_OR: priority = 7; break;
1803 
1804 				case Variant::OP_LESS: priority = 8; break;
1805 				case Variant::OP_LESS_EQUAL: priority = 8; break;
1806 				case Variant::OP_GREATER: priority = 8; break;
1807 				case Variant::OP_GREATER_EQUAL: priority = 8; break;
1808 
1809 				case Variant::OP_EQUAL: priority = 8; break;
1810 				case Variant::OP_NOT_EQUAL: priority = 8; break;
1811 
1812 				case Variant::OP_IN: priority = 10; break;
1813 
1814 				case Variant::OP_NOT:
1815 					priority = 11;
1816 					unary = true;
1817 					break;
1818 				case Variant::OP_AND: priority = 12; break;
1819 				case Variant::OP_OR: priority = 13; break;
1820 
1821 				default: {
1822 					_set_error("Parser bug, invalid operator in expression: " + itos(expression[i].op));
1823 					return NULL;
1824 				}
1825 			}
1826 
1827 			if (priority < min_priority) {
1828 				// < is used for left to right (default)
1829 				// <= is used for right to left
1830 
1831 				next_op = i;
1832 				min_priority = priority;
1833 				is_unary = unary;
1834 			}
1835 		}
1836 
1837 		if (next_op == -1) {
1838 
1839 			_set_error("Yet another parser bug....");
1840 			ERR_FAIL_V(NULL);
1841 		}
1842 
1843 		// OK! create operator..
1844 		if (is_unary) {
1845 
1846 			int expr_pos = next_op;
1847 			while (expression[expr_pos].is_op) {
1848 
1849 				expr_pos++;
1850 				if (expr_pos == expression.size()) {
1851 					//can happen..
1852 					_set_error("Unexpected end of expression...");
1853 					return NULL;
1854 				}
1855 			}
1856 
1857 			//consecutively do unary opeators
1858 			for (int i = expr_pos - 1; i >= next_op; i--) {
1859 
1860 				OperatorNode *op = alloc_node<OperatorNode>();
1861 				op->op = expression[i].op;
1862 				op->nodes[0] = expression[i + 1].node;
1863 				op->nodes[1] = NULL;
1864 				expression.write[i].is_op = false;
1865 				expression.write[i].node = op;
1866 				expression.remove(i + 1);
1867 			}
1868 
1869 		} else {
1870 
1871 			if (next_op < 1 || next_op >= (expression.size() - 1)) {
1872 				_set_error("Parser bug...");
1873 				ERR_FAIL_V(NULL);
1874 			}
1875 
1876 			OperatorNode *op = alloc_node<OperatorNode>();
1877 			op->op = expression[next_op].op;
1878 
1879 			if (expression[next_op - 1].is_op) {
1880 
1881 				_set_error("Parser bug...");
1882 				ERR_FAIL_V(NULL);
1883 			}
1884 
1885 			if (expression[next_op + 1].is_op) {
1886 				// this is not invalid and can really appear
1887 				// but it becomes invalid anyway because no binary op
1888 				// can be followed by a unary op in a valid combination,
1889 				// due to how precedence works, unaries will always disappear first
1890 
1891 				_set_error("Unexpected two consecutive operators.");
1892 				return NULL;
1893 			}
1894 
1895 			op->nodes[0] = expression[next_op - 1].node; //expression goes as left
1896 			op->nodes[1] = expression[next_op + 1].node; //next expression goes as right
1897 
1898 			//replace all 3 nodes by this operator and make it an expression
1899 			expression.write[next_op - 1].node = op;
1900 			expression.remove(next_op);
1901 			expression.remove(next_op);
1902 		}
1903 	}
1904 
1905 	return expression[0].node;
1906 }
1907 
_compile_expression()1908 bool Expression::_compile_expression() {
1909 
1910 	if (!expression_dirty)
1911 		return error_set;
1912 
1913 	if (nodes) {
1914 		memdelete(nodes);
1915 		nodes = NULL;
1916 		root = NULL;
1917 	}
1918 
1919 	error_str = String();
1920 	error_set = false;
1921 	str_ofs = 0;
1922 
1923 	root = _parse_expression();
1924 
1925 	if (error_set) {
1926 		root = NULL;
1927 		if (nodes) {
1928 			memdelete(nodes);
1929 		}
1930 		nodes = NULL;
1931 		return true;
1932 	}
1933 
1934 	expression_dirty = false;
1935 	return false;
1936 }
1937 
_execute(const Array & p_inputs,Object * p_instance,Expression::ENode * p_node,Variant & r_ret,String & r_error_str)1938 bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression::ENode *p_node, Variant &r_ret, String &r_error_str) {
1939 
1940 	switch (p_node->type) {
1941 		case Expression::ENode::TYPE_INPUT: {
1942 
1943 			const Expression::InputNode *in = static_cast<const Expression::InputNode *>(p_node);
1944 			if (in->index < 0 || in->index >= p_inputs.size()) {
1945 				r_error_str = vformat(RTR("Invalid input %i (not passed) in expression"), in->index);
1946 				return true;
1947 			}
1948 			r_ret = p_inputs[in->index];
1949 		} break;
1950 		case Expression::ENode::TYPE_CONSTANT: {
1951 
1952 			const Expression::ConstantNode *c = static_cast<const Expression::ConstantNode *>(p_node);
1953 			r_ret = c->value;
1954 
1955 		} break;
1956 		case Expression::ENode::TYPE_SELF: {
1957 
1958 			if (!p_instance) {
1959 				r_error_str = RTR("self can't be used because instance is null (not passed)");
1960 				return true;
1961 			}
1962 			r_ret = p_instance;
1963 		} break;
1964 		case Expression::ENode::TYPE_OPERATOR: {
1965 
1966 			const Expression::OperatorNode *op = static_cast<const Expression::OperatorNode *>(p_node);
1967 
1968 			Variant a;
1969 			bool ret = _execute(p_inputs, p_instance, op->nodes[0], a, r_error_str);
1970 			if (ret)
1971 				return true;
1972 
1973 			Variant b;
1974 
1975 			if (op->nodes[1]) {
1976 				ret = _execute(p_inputs, p_instance, op->nodes[1], b, r_error_str);
1977 				if (ret)
1978 					return true;
1979 			}
1980 
1981 			bool valid = true;
1982 			Variant::evaluate(op->op, a, b, r_ret, valid);
1983 			if (!valid) {
1984 				r_error_str = vformat(RTR("Invalid operands to operator %s, %s and %s."), Variant::get_operator_name(op->op), Variant::get_type_name(a.get_type()), Variant::get_type_name(b.get_type()));
1985 				return true;
1986 			}
1987 
1988 		} break;
1989 		case Expression::ENode::TYPE_INDEX: {
1990 
1991 			const Expression::IndexNode *index = static_cast<const Expression::IndexNode *>(p_node);
1992 
1993 			Variant base;
1994 			bool ret = _execute(p_inputs, p_instance, index->base, base, r_error_str);
1995 			if (ret)
1996 				return true;
1997 
1998 			Variant idx;
1999 
2000 			ret = _execute(p_inputs, p_instance, index->index, idx, r_error_str);
2001 			if (ret)
2002 				return true;
2003 
2004 			bool valid;
2005 			r_ret = base.get(idx, &valid);
2006 			if (!valid) {
2007 				r_error_str = vformat(RTR("Invalid index of type %s for base type %s"), Variant::get_type_name(idx.get_type()), Variant::get_type_name(base.get_type()));
2008 				return true;
2009 			}
2010 
2011 		} break;
2012 		case Expression::ENode::TYPE_NAMED_INDEX: {
2013 
2014 			const Expression::NamedIndexNode *index = static_cast<const Expression::NamedIndexNode *>(p_node);
2015 
2016 			Variant base;
2017 			bool ret = _execute(p_inputs, p_instance, index->base, base, r_error_str);
2018 			if (ret)
2019 				return true;
2020 
2021 			bool valid;
2022 			r_ret = base.get_named(index->name, &valid);
2023 			if (!valid) {
2024 				r_error_str = vformat(RTR("Invalid named index '%s' for base type %s"), String(index->name), Variant::get_type_name(base.get_type()));
2025 				return true;
2026 			}
2027 
2028 		} break;
2029 		case Expression::ENode::TYPE_ARRAY: {
2030 			const Expression::ArrayNode *array = static_cast<const Expression::ArrayNode *>(p_node);
2031 
2032 			Array arr;
2033 			arr.resize(array->array.size());
2034 			for (int i = 0; i < array->array.size(); i++) {
2035 
2036 				Variant value;
2037 				bool ret = _execute(p_inputs, p_instance, array->array[i], value, r_error_str);
2038 
2039 				if (ret)
2040 					return true;
2041 				arr[i] = value;
2042 			}
2043 
2044 			r_ret = arr;
2045 
2046 		} break;
2047 		case Expression::ENode::TYPE_DICTIONARY: {
2048 			const Expression::DictionaryNode *dictionary = static_cast<const Expression::DictionaryNode *>(p_node);
2049 
2050 			Dictionary d;
2051 			for (int i = 0; i < dictionary->dict.size(); i += 2) {
2052 
2053 				Variant key;
2054 				bool ret = _execute(p_inputs, p_instance, dictionary->dict[i + 0], key, r_error_str);
2055 
2056 				if (ret)
2057 					return true;
2058 
2059 				Variant value;
2060 				ret = _execute(p_inputs, p_instance, dictionary->dict[i + 1], value, r_error_str);
2061 				if (ret)
2062 					return true;
2063 
2064 				d[key] = value;
2065 			}
2066 
2067 			r_ret = d;
2068 		} break;
2069 		case Expression::ENode::TYPE_CONSTRUCTOR: {
2070 
2071 			const Expression::ConstructorNode *constructor = static_cast<const Expression::ConstructorNode *>(p_node);
2072 
2073 			Vector<Variant> arr;
2074 			Vector<const Variant *> argp;
2075 			arr.resize(constructor->arguments.size());
2076 			argp.resize(constructor->arguments.size());
2077 
2078 			for (int i = 0; i < constructor->arguments.size(); i++) {
2079 
2080 				Variant value;
2081 				bool ret = _execute(p_inputs, p_instance, constructor->arguments[i], value, r_error_str);
2082 
2083 				if (ret)
2084 					return true;
2085 				arr.write[i] = value;
2086 				argp.write[i] = &arr[i];
2087 			}
2088 
2089 			Variant::CallError ce;
2090 			r_ret = Variant::construct(constructor->data_type, (const Variant **)argp.ptr(), argp.size(), ce);
2091 
2092 			if (ce.error != Variant::CallError::CALL_OK) {
2093 				r_error_str = vformat(RTR("Invalid arguments to construct '%s'"), Variant::get_type_name(constructor->data_type));
2094 				return true;
2095 			}
2096 
2097 		} break;
2098 		case Expression::ENode::TYPE_BUILTIN_FUNC: {
2099 
2100 			const Expression::BuiltinFuncNode *bifunc = static_cast<const Expression::BuiltinFuncNode *>(p_node);
2101 
2102 			Vector<Variant> arr;
2103 			Vector<const Variant *> argp;
2104 			arr.resize(bifunc->arguments.size());
2105 			argp.resize(bifunc->arguments.size());
2106 
2107 			for (int i = 0; i < bifunc->arguments.size(); i++) {
2108 
2109 				Variant value;
2110 				bool ret = _execute(p_inputs, p_instance, bifunc->arguments[i], value, r_error_str);
2111 				if (ret)
2112 					return true;
2113 				arr.write[i] = value;
2114 				argp.write[i] = &arr[i];
2115 			}
2116 
2117 			Variant::CallError ce;
2118 			exec_func(bifunc->func, (const Variant **)argp.ptr(), &r_ret, ce, r_error_str);
2119 
2120 			if (ce.error != Variant::CallError::CALL_OK) {
2121 				r_error_str = "Builtin Call Failed. " + r_error_str;
2122 				return true;
2123 			}
2124 
2125 		} break;
2126 		case Expression::ENode::TYPE_CALL: {
2127 
2128 			const Expression::CallNode *call = static_cast<const Expression::CallNode *>(p_node);
2129 
2130 			Variant base;
2131 			bool ret = _execute(p_inputs, p_instance, call->base, base, r_error_str);
2132 
2133 			if (ret)
2134 				return true;
2135 
2136 			Vector<Variant> arr;
2137 			Vector<const Variant *> argp;
2138 			arr.resize(call->arguments.size());
2139 			argp.resize(call->arguments.size());
2140 
2141 			for (int i = 0; i < call->arguments.size(); i++) {
2142 
2143 				Variant value;
2144 				ret = _execute(p_inputs, p_instance, call->arguments[i], value, r_error_str);
2145 
2146 				if (ret)
2147 					return true;
2148 				arr.write[i] = value;
2149 				argp.write[i] = &arr[i];
2150 			}
2151 
2152 			Variant::CallError ce;
2153 			r_ret = base.call(call->method, (const Variant **)argp.ptr(), argp.size(), ce);
2154 
2155 			if (ce.error != Variant::CallError::CALL_OK) {
2156 				r_error_str = vformat(RTR("On call to '%s':"), String(call->method));
2157 				return true;
2158 			}
2159 
2160 		} break;
2161 	}
2162 	return false;
2163 }
2164 
parse(const String & p_expression,const Vector<String> & p_input_names)2165 Error Expression::parse(const String &p_expression, const Vector<String> &p_input_names) {
2166 
2167 	if (nodes) {
2168 		memdelete(nodes);
2169 		nodes = NULL;
2170 		root = NULL;
2171 	}
2172 
2173 	error_str = String();
2174 	error_set = false;
2175 	str_ofs = 0;
2176 	input_names = p_input_names;
2177 
2178 	expression = p_expression;
2179 	root = _parse_expression();
2180 
2181 	if (error_set) {
2182 		root = NULL;
2183 		if (nodes) {
2184 			memdelete(nodes);
2185 		}
2186 		nodes = NULL;
2187 		return ERR_INVALID_PARAMETER;
2188 	}
2189 
2190 	return OK;
2191 }
2192 
execute(Array p_inputs,Object * p_base,bool p_show_error)2193 Variant Expression::execute(Array p_inputs, Object *p_base, bool p_show_error) {
2194 
2195 	ERR_FAIL_COND_V_MSG(error_set, Variant(), "There was previously a parse error: " + error_str + ".");
2196 
2197 	execution_error = false;
2198 	Variant output;
2199 	String error_txt;
2200 	bool err = _execute(p_inputs, p_base, root, output, error_txt);
2201 	if (err) {
2202 		execution_error = true;
2203 		error_str = error_txt;
2204 		ERR_FAIL_COND_V_MSG(p_show_error, Variant(), error_str);
2205 	}
2206 
2207 	return output;
2208 }
2209 
has_execute_failed() const2210 bool Expression::has_execute_failed() const {
2211 	return execution_error;
2212 }
2213 
get_error_text() const2214 String Expression::get_error_text() const {
2215 	return error_str;
2216 }
2217 
_bind_methods()2218 void Expression::_bind_methods() {
2219 
2220 	ClassDB::bind_method(D_METHOD("parse", "expression", "input_names"), &Expression::parse, DEFVAL(Vector<String>()));
2221 	ClassDB::bind_method(D_METHOD("execute", "inputs", "base_instance", "show_error"), &Expression::execute, DEFVAL(Array()), DEFVAL(Variant()), DEFVAL(true));
2222 	ClassDB::bind_method(D_METHOD("has_execute_failed"), &Expression::has_execute_failed);
2223 	ClassDB::bind_method(D_METHOD("get_error_text"), &Expression::get_error_text);
2224 }
2225 
Expression()2226 Expression::Expression() :
2227 		output_type(Variant::NIL),
2228 		sequenced(false),
2229 		error_set(true),
2230 		root(NULL),
2231 		nodes(NULL),
2232 		execution_error(false) {
2233 }
2234 
~Expression()2235 Expression::~Expression() {
2236 
2237 	if (nodes) {
2238 		memdelete(nodes);
2239 	}
2240 }
2241