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