2018-08-29 22:38:13 +02:00
/*************************************************************************/
/* expression.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
2019-01-01 12:53:14 +01:00
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
2018-08-29 22:38:13 +02:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-08-08 22:34:24 +02:00
# include "expression.h"
2018-09-11 18:13:45 +02:00
# include "core/class_db.h"
# include "core/func_ref.h"
# include "core/io/marshalls.h"
# include "core/math/math_funcs.h"
# include "core/os/os.h"
# include "core/reference.h"
# include "core/variant_parser.h"
2018-08-08 22:34:24 +02:00
const char * Expression : : func_name [ Expression : : FUNC_MAX ] = {
" sin " ,
" cos " ,
" tan " ,
" sinh " ,
" cosh " ,
" tanh " ,
" asin " ,
" acos " ,
" atan " ,
" atan2 " ,
" sqrt " ,
" fmod " ,
" fposmod " ,
" floor " ,
" ceil " ,
" round " ,
" abs " ,
" sign " ,
" pow " ,
" log " ,
" exp " ,
" is_nan " ,
" is_inf " ,
" ease " ,
" decimals " ,
" stepify " ,
" lerp " ,
" inverse_lerp " ,
" range_lerp " ,
2019-03-19 12:39:43 +01:00
" smoothstep " ,
2018-08-08 22:34:24 +02:00
" dectime " ,
" randomize " ,
" randi " ,
" randf " ,
" rand_range " ,
" seed " ,
" rand_seed " ,
" deg2rad " ,
" rad2deg " ,
" linear2db " ,
" db2linear " ,
" polar2cartesian " ,
" cartesian2polar " ,
" wrapi " ,
" wrapf " ,
" max " ,
" min " ,
" clamp " ,
" nearest_po2 " ,
" weakref " ,
" funcref " ,
" convert " ,
" typeof " ,
" type_exists " ,
" char " ,
" str " ,
" print " ,
" printerr " ,
" printraw " ,
" var2str " ,
" str2var " ,
" var2bytes " ,
" bytes2var " ,
" color_named " ,
} ;
Expression : : BuiltinFunc Expression : : find_function ( const String & p_string ) {
for ( int i = 0 ; i < FUNC_MAX ; i + + ) {
if ( p_string = = func_name [ i ] )
return BuiltinFunc ( i ) ;
}
return FUNC_MAX ;
}
String Expression : : get_func_name ( BuiltinFunc p_func ) {
ERR_FAIL_INDEX_V ( p_func , FUNC_MAX , String ( ) ) ;
return func_name [ p_func ] ;
}
int Expression : : get_func_argument_count ( BuiltinFunc p_func ) {
switch ( p_func ) {
case MATH_RANDOMIZE :
case MATH_RAND :
case MATH_RANDF :
return 0 ;
case MATH_SIN :
case MATH_COS :
case MATH_TAN :
case MATH_SINH :
case MATH_COSH :
case MATH_TANH :
case MATH_ASIN :
case MATH_ACOS :
case MATH_ATAN :
case MATH_SQRT :
case MATH_FLOOR :
case MATH_CEIL :
case MATH_ROUND :
case MATH_ABS :
case MATH_SIGN :
case MATH_LOG :
case MATH_EXP :
case MATH_ISNAN :
case MATH_ISINF :
case MATH_DECIMALS :
case MATH_SEED :
case MATH_RANDSEED :
case MATH_DEG2RAD :
case MATH_RAD2DEG :
case MATH_LINEAR2DB :
case MATH_DB2LINEAR :
case LOGIC_NEAREST_PO2 :
case OBJ_WEAKREF :
case TYPE_OF :
case TEXT_CHAR :
case TEXT_STR :
case TEXT_PRINT :
case TEXT_PRINTERR :
case TEXT_PRINTRAW :
case VAR_TO_STR :
case STR_TO_VAR :
case TYPE_EXISTS :
return 1 ;
2019-03-26 16:52:42 +01:00
case VAR_TO_BYTES :
case BYTES_TO_VAR :
2018-08-08 22:34:24 +02:00
case MATH_ATAN2 :
case MATH_FMOD :
case MATH_FPOSMOD :
case MATH_POW :
case MATH_EASE :
case MATH_STEPIFY :
case MATH_RANDOM :
case MATH_POLAR2CARTESIAN :
case MATH_CARTESIAN2POLAR :
case LOGIC_MAX :
case LOGIC_MIN :
case FUNC_FUNCREF :
case TYPE_CONVERT :
case COLORN :
return 2 ;
case MATH_LERP :
case MATH_INVERSE_LERP :
2019-03-19 12:39:43 +01:00
case MATH_SMOOTHSTEP :
2018-08-08 22:34:24 +02:00
case MATH_DECTIME :
case MATH_WRAP :
case MATH_WRAPF :
case LOGIC_CLAMP :
return 3 ;
case MATH_RANGE_LERP :
return 5 ;
case FUNC_MAX : {
}
}
return 0 ;
}
# define VALIDATE_ARG_NUM(m_arg) \
if ( ! p_inputs [ m_arg ] - > is_num ( ) ) { \
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ; \
r_error . argument = m_arg ; \
r_error . expected = Variant : : REAL ; \
return ; \
}
void Expression : : exec_func ( BuiltinFunc p_func , const Variant * * p_inputs , Variant * r_return , Variant : : CallError & r_error , String & r_error_str ) {
2018-08-22 10:58:27 +02:00
r_error . error = Variant : : CallError : : CALL_OK ;
2018-08-08 22:34:24 +02:00
switch ( p_func ) {
case MATH_SIN : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : sin ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_COS : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : cos ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_TAN : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : tan ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_SINH : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : sinh ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_COSH : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : cosh ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_TANH : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : tanh ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ASIN : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : asin ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ACOS : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : acos ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ATAN : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : atan ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ATAN2 : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : atan2 ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_SQRT : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : sqrt ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_FMOD : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : fmod ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_FPOSMOD : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : fposmod ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_FLOOR : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : floor ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_CEIL : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : ceil ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ROUND : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : round ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ABS : {
if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : INT ) {
int64_t i = * p_inputs [ 0 ] ;
* r_return = ABS ( i ) ;
} else if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : REAL ) {
real_t r = * p_inputs [ 0 ] ;
* r_return = Math : : abs ( r ) ;
} else {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : REAL ;
}
} break ;
case MATH_SIGN : {
if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : INT ) {
int64_t i = * p_inputs [ 0 ] ;
* r_return = i < 0 ? - 1 : ( i > 0 ? + 1 : 0 ) ;
} else if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : REAL ) {
real_t r = * p_inputs [ 0 ] ;
* r_return = r < 0.0 ? - 1.0 : ( r > 0.0 ? + 1.0 : 0.0 ) ;
} else {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : REAL ;
}
} break ;
case MATH_POW : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : pow ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_LOG : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : log ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_EXP : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : exp ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ISNAN : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : is_nan ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_ISINF : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : is_inf ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_EASE : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : ease ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_DECIMALS : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : step_decimals ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_STEPIFY : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : stepify ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_LERP : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : lerp ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] , ( double ) * p_inputs [ 2 ] ) ;
} break ;
case MATH_INVERSE_LERP : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : inverse_lerp ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] , ( double ) * p_inputs [ 2 ] ) ;
} break ;
case MATH_RANGE_LERP : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
VALIDATE_ARG_NUM ( 3 ) ;
VALIDATE_ARG_NUM ( 4 ) ;
* 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 ] ) ;
} break ;
2019-03-19 12:39:43 +01:00
case MATH_SMOOTHSTEP : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : smoothstep ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] , ( double ) * p_inputs [ 2 ] ) ;
} break ;
2018-08-08 22:34:24 +02:00
case MATH_DECTIME : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : dectime ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] , ( double ) * p_inputs [ 2 ] ) ;
} break ;
case MATH_RANDOMIZE : {
Math : : randomize ( ) ;
} break ;
case MATH_RAND : {
* r_return = Math : : rand ( ) ;
} break ;
case MATH_RANDF : {
* r_return = Math : : randf ( ) ;
} break ;
case MATH_RANDOM : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
* r_return = Math : : random ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] ) ;
} break ;
case MATH_SEED : {
VALIDATE_ARG_NUM ( 0 ) ;
uint64_t seed = * p_inputs [ 0 ] ;
Math : : seed ( seed ) ;
} break ;
case MATH_RANDSEED : {
VALIDATE_ARG_NUM ( 0 ) ;
uint64_t seed = * p_inputs [ 0 ] ;
int ret = Math : : rand_from_seed ( & seed ) ;
Array reta ;
reta . push_back ( ret ) ;
reta . push_back ( seed ) ;
* r_return = reta ;
} break ;
case MATH_DEG2RAD : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : deg2rad ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_RAD2DEG : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : rad2deg ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_LINEAR2DB : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : linear2db ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_DB2LINEAR : {
VALIDATE_ARG_NUM ( 0 ) ;
* r_return = Math : : db2linear ( ( double ) * p_inputs [ 0 ] ) ;
} break ;
case MATH_POLAR2CARTESIAN : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
double r = * p_inputs [ 0 ] ;
double th = * p_inputs [ 1 ] ;
* r_return = Vector2 ( r * Math : : cos ( th ) , r * Math : : sin ( th ) ) ;
} break ;
case MATH_CARTESIAN2POLAR : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
double x = * p_inputs [ 0 ] ;
double y = * p_inputs [ 1 ] ;
* r_return = Vector2 ( Math : : sqrt ( x * x + y * y ) , Math : : atan2 ( y , x ) ) ;
} break ;
case MATH_WRAP : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : wrapi ( ( int64_t ) * p_inputs [ 0 ] , ( int64_t ) * p_inputs [ 1 ] , ( int64_t ) * p_inputs [ 2 ] ) ;
} break ;
case MATH_WRAPF : {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
* r_return = Math : : wrapf ( ( double ) * p_inputs [ 0 ] , ( double ) * p_inputs [ 1 ] , ( double ) * p_inputs [ 2 ] ) ;
} break ;
case LOGIC_MAX : {
if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : INT & & p_inputs [ 1 ] - > get_type ( ) = = Variant : : INT ) {
int64_t a = * p_inputs [ 0 ] ;
int64_t b = * p_inputs [ 1 ] ;
* r_return = MAX ( a , b ) ;
} else {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
real_t a = * p_inputs [ 0 ] ;
real_t b = * p_inputs [ 1 ] ;
* r_return = MAX ( a , b ) ;
}
} break ;
case LOGIC_MIN : {
if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : INT & & p_inputs [ 1 ] - > get_type ( ) = = Variant : : INT ) {
int64_t a = * p_inputs [ 0 ] ;
int64_t b = * p_inputs [ 1 ] ;
* r_return = MIN ( a , b ) ;
} else {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
real_t a = * p_inputs [ 0 ] ;
real_t b = * p_inputs [ 1 ] ;
* r_return = MIN ( a , b ) ;
}
} break ;
case LOGIC_CLAMP : {
if ( p_inputs [ 0 ] - > get_type ( ) = = Variant : : INT & & p_inputs [ 1 ] - > get_type ( ) = = Variant : : INT & & p_inputs [ 2 ] - > get_type ( ) = = Variant : : INT ) {
int64_t a = * p_inputs [ 0 ] ;
int64_t b = * p_inputs [ 1 ] ;
int64_t c = * p_inputs [ 2 ] ;
* r_return = CLAMP ( a , b , c ) ;
} else {
VALIDATE_ARG_NUM ( 0 ) ;
VALIDATE_ARG_NUM ( 1 ) ;
VALIDATE_ARG_NUM ( 2 ) ;
real_t a = * p_inputs [ 0 ] ;
real_t b = * p_inputs [ 1 ] ;
real_t c = * p_inputs [ 2 ] ;
* r_return = CLAMP ( a , b , c ) ;
}
} break ;
case LOGIC_NEAREST_PO2 : {
VALIDATE_ARG_NUM ( 0 ) ;
int64_t num = * p_inputs [ 0 ] ;
* r_return = next_power_of_2 ( num ) ;
} break ;
case OBJ_WEAKREF : {
if ( p_inputs [ 0 ] - > get_type ( ) ! = Variant : : OBJECT ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : OBJECT ;
return ;
}
if ( p_inputs [ 0 ] - > is_ref ( ) ) {
REF r = * p_inputs [ 0 ] ;
if ( ! r . is_valid ( ) ) {
return ;
}
Ref < WeakRef > wref = memnew ( WeakRef ) ;
wref - > set_ref ( r ) ;
* r_return = wref ;
} else {
Object * obj = * p_inputs [ 0 ] ;
if ( ! obj ) {
return ;
}
Ref < WeakRef > wref = memnew ( WeakRef ) ;
wref - > set_obj ( obj ) ;
* r_return = wref ;
}
} break ;
case FUNC_FUNCREF : {
if ( p_inputs [ 0 ] - > get_type ( ) ! = Variant : : OBJECT ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : OBJECT ;
return ;
}
if ( p_inputs [ 1 ] - > get_type ( ) ! = Variant : : STRING & & p_inputs [ 1 ] - > get_type ( ) ! = Variant : : NODE_PATH ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 1 ;
r_error . expected = Variant : : STRING ;
return ;
}
Ref < FuncRef > fr = memnew ( FuncRef ) ;
fr - > set_instance ( * p_inputs [ 0 ] ) ;
fr - > set_function ( * p_inputs [ 1 ] ) ;
* r_return = fr ;
} break ;
case TYPE_CONVERT : {
VALIDATE_ARG_NUM ( 1 ) ;
int type = * p_inputs [ 1 ] ;
if ( type < 0 | | type > = Variant : : VARIANT_MAX ) {
r_error_str = RTR ( " Invalid type argument to convert(), use TYPE_* constants. " ) ;
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : INT ;
return ;
} else {
* r_return = Variant : : construct ( Variant : : Type ( type ) , p_inputs , 1 , r_error ) ;
}
} break ;
case TYPE_OF : {
* r_return = p_inputs [ 0 ] - > get_type ( ) ;
} break ;
case TYPE_EXISTS : {
* r_return = ClassDB : : class_exists ( * p_inputs [ 0 ] ) ;
} break ;
case TEXT_CHAR : {
CharType result [ 2 ] = { * p_inputs [ 0 ] , 0 } ;
* r_return = String ( result ) ;
} break ;
case TEXT_STR : {
String str = * p_inputs [ 0 ] ;
* r_return = str ;
} break ;
case TEXT_PRINT : {
String str = * p_inputs [ 0 ] ;
print_line ( str ) ;
} break ;
case TEXT_PRINTERR : {
String str = * p_inputs [ 0 ] ;
print_error ( str ) ;
} break ;
case TEXT_PRINTRAW : {
2018-08-24 09:35:07 +02:00
String str = * p_inputs [ 0 ] ;
2018-08-08 22:34:24 +02:00
OS : : get_singleton ( ) - > print ( " %s " , str . utf8 ( ) . get_data ( ) ) ;
} break ;
case VAR_TO_STR : {
String vars ;
VariantWriter : : write_to_string ( * p_inputs [ 0 ] , vars ) ;
* r_return = vars ;
} break ;
case STR_TO_VAR : {
if ( p_inputs [ 0 ] - > get_type ( ) ! = Variant : : STRING ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : STRING ;
return ;
}
VariantParser : : StreamString ss ;
ss . s = * p_inputs [ 0 ] ;
String errs ;
int line ;
Error err = VariantParser : : parse ( & ss , * r_return , errs , line ) ;
if ( err ! = OK ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : STRING ;
* r_return = " Parse error at line " + itos ( line ) + " : " + errs ;
return ;
}
} break ;
case VAR_TO_BYTES : {
PoolByteArray barr ;
2019-03-26 16:52:42 +01:00
bool full_objects = * p_inputs [ 1 ] ;
2018-08-08 22:34:24 +02:00
int len ;
2019-03-26 16:52:42 +01:00
Error err = encode_variant ( * p_inputs [ 0 ] , NULL , len , full_objects ) ;
2018-08-08 22:34:24 +02:00
if ( err ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : NIL ;
r_error_str = " Unexpected error encoding variable to bytes, likely unserializable type found (Object or RID). " ;
return ;
}
barr . resize ( len ) ;
{
PoolByteArray : : Write w = barr . write ( ) ;
2019-03-26 16:52:42 +01:00
encode_variant ( * p_inputs [ 0 ] , w . ptr ( ) , len , full_objects ) ;
2018-08-08 22:34:24 +02:00
}
* r_return = barr ;
} break ;
case BYTES_TO_VAR : {
if ( p_inputs [ 0 ] - > get_type ( ) ! = Variant : : POOL_BYTE_ARRAY ) {
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : POOL_BYTE_ARRAY ;
return ;
}
PoolByteArray varr = * p_inputs [ 0 ] ;
2019-03-26 16:52:42 +01:00
bool allow_objects = * p_inputs [ 1 ] ;
2018-08-08 22:34:24 +02:00
Variant ret ;
{
PoolByteArray : : Read r = varr . read ( ) ;
2019-03-26 16:52:42 +01:00
Error err = decode_variant ( ret , r . ptr ( ) , varr . size ( ) , NULL , allow_objects ) ;
2018-08-08 22:34:24 +02:00
if ( err ! = OK ) {
r_error_str = RTR ( " Not enough bytes for decoding bytes, or invalid format. " ) ;
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ;
r_error . argument = 0 ;
r_error . expected = Variant : : POOL_BYTE_ARRAY ;
return ;
}
}
* r_return = ret ;
} break ;
case COLORN : {
VALIDATE_ARG_NUM ( 1 ) ;
Color color = Color : : named ( * p_inputs [ 0 ] ) ;
color . a = * p_inputs [ 1 ] ;
* r_return = String ( color ) ;
} break ;
default : { }
}
}
////////
2018-10-01 16:06:21 +02:00
static bool _is_number ( CharType c ) {
return ( c > = ' 0 ' & & c < = ' 9 ' ) ;
}
2018-08-08 22:34:24 +02:00
Error Expression : : _get_token ( Token & r_token ) {
while ( true ) {
# define GET_CHAR() (str_ofs >= expression.length() ? 0 : expression[str_ofs++])
CharType cchar = GET_CHAR ( ) ;
if ( cchar = = 0 ) {
r_token . type = TK_EOF ;
return OK ;
}
switch ( cchar ) {
case 0 : {
r_token . type = TK_EOF ;
return OK ;
} break ;
case ' { ' : {
r_token . type = TK_CURLY_BRACKET_OPEN ;
return OK ;
} ;
case ' } ' : {
r_token . type = TK_CURLY_BRACKET_CLOSE ;
return OK ;
} ;
case ' [ ' : {
r_token . type = TK_BRACKET_OPEN ;
return OK ;
} ;
case ' ] ' : {
r_token . type = TK_BRACKET_CLOSE ;
return OK ;
} ;
case ' ( ' : {
r_token . type = TK_PARENTHESIS_OPEN ;
return OK ;
} ;
case ' ) ' : {
r_token . type = TK_PARENTHESIS_CLOSE ;
return OK ;
} ;
case ' , ' : {
r_token . type = TK_COMMA ;
return OK ;
} ;
case ' : ' : {
r_token . type = TK_COLON ;
return OK ;
} ;
case ' $ ' : {
r_token . type = TK_INPUT ;
int index = 0 ;
do {
2018-10-01 16:06:21 +02:00
if ( ! _is_number ( expression [ str_ofs ] ) ) {
2018-08-08 22:34:24 +02:00
_set_error ( " Expected number after '$' " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
index * = 10 ;
index + = expression [ str_ofs ] - ' 0 ' ;
str_ofs + + ;
2018-10-01 16:06:21 +02:00
} while ( _is_number ( expression [ str_ofs ] ) ) ;
2018-08-08 22:34:24 +02:00
r_token . value = index ;
return OK ;
} ;
case ' = ' : {
cchar = GET_CHAR ( ) ;
if ( cchar = = ' = ' ) {
r_token . type = TK_OP_EQUAL ;
} else {
_set_error ( " Expected '=' " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
return OK ;
} ;
case ' ! ' : {
if ( expression [ str_ofs ] = = ' = ' ) {
r_token . type = TK_OP_NOT_EQUAL ;
str_ofs + + ;
} else {
r_token . type = TK_OP_NOT ;
}
return OK ;
} ;
case ' > ' : {
if ( expression [ str_ofs ] = = ' = ' ) {
r_token . type = TK_OP_GREATER_EQUAL ;
str_ofs + + ;
} else if ( expression [ str_ofs ] = = ' > ' ) {
r_token . type = TK_OP_SHIFT_RIGHT ;
str_ofs + + ;
} else {
r_token . type = TK_OP_GREATER ;
}
return OK ;
} ;
case ' < ' : {
if ( expression [ str_ofs ] = = ' = ' ) {
r_token . type = TK_OP_LESS_EQUAL ;
str_ofs + + ;
} else if ( expression [ str_ofs ] = = ' < ' ) {
r_token . type = TK_OP_SHIFT_LEFT ;
str_ofs + + ;
} else {
r_token . type = TK_OP_LESS ;
}
return OK ;
} ;
case ' + ' : {
r_token . type = TK_OP_ADD ;
return OK ;
} ;
case ' - ' : {
r_token . type = TK_OP_SUB ;
return OK ;
} ;
case ' / ' : {
r_token . type = TK_OP_DIV ;
return OK ;
} ;
case ' * ' : {
r_token . type = TK_OP_MUL ;
return OK ;
} ;
case ' % ' : {
r_token . type = TK_OP_MOD ;
return OK ;
} ;
case ' & ' : {
if ( expression [ str_ofs ] = = ' & ' ) {
r_token . type = TK_OP_AND ;
str_ofs + + ;
} else {
r_token . type = TK_OP_BIT_AND ;
}
return OK ;
} ;
case ' | ' : {
if ( expression [ str_ofs ] = = ' | ' ) {
r_token . type = TK_OP_OR ;
str_ofs + + ;
} else {
r_token . type = TK_OP_BIT_OR ;
}
return OK ;
} ;
case ' ^ ' : {
r_token . type = TK_OP_BIT_XOR ;
return OK ;
} ;
case ' ~ ' : {
r_token . type = TK_OP_BIT_INVERT ;
return OK ;
} ;
case ' " ' : {
String str ;
while ( true ) {
CharType ch = GET_CHAR ( ) ;
if ( ch = = 0 ) {
_set_error ( " Unterminated String " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
} else if ( ch = = ' " ' ) {
break ;
} else if ( ch = = ' \\ ' ) {
//escaped characters...
CharType next = GET_CHAR ( ) ;
if ( next = = 0 ) {
_set_error ( " Unterminated String " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
CharType res = 0 ;
switch ( next ) {
case ' b ' : res = 8 ; break ;
case ' t ' : res = 9 ; break ;
case ' n ' : res = 10 ; break ;
case ' f ' : res = 12 ; break ;
case ' r ' : res = 13 ; break ;
case ' u ' : {
//hexnumbarh - oct is deprecated
for ( int j = 0 ; j < 4 ; j + + ) {
CharType c = GET_CHAR ( ) ;
if ( c = = 0 ) {
_set_error ( " Unterminated String " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
2018-10-01 16:06:21 +02:00
if ( ! ( _is_number ( c ) | | ( c > = ' a ' & & c < = ' f ' ) | | ( c > = ' A ' & & c < = ' F ' ) ) ) {
2018-08-08 22:34:24 +02:00
_set_error ( " Malformed hex constant in string " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
CharType v ;
2018-10-01 16:06:21 +02:00
if ( _is_number ( c ) ) {
2018-08-08 22:34:24 +02:00
v = c - ' 0 ' ;
} else if ( c > = ' a ' & & c < = ' f ' ) {
v = c - ' a ' ;
v + = 10 ;
} else if ( c > = ' A ' & & c < = ' F ' ) {
v = c - ' A ' ;
v + = 10 ;
} else {
ERR_PRINT ( " BUG " ) ;
v = 0 ;
}
res < < = 4 ;
res | = v ;
}
} break ;
//case '\"': res='\"'; break;
//case '\\': res='\\'; break;
//case '/': res='/'; break;
default : {
res = next ;
//r_err_str="Invalid escape sequence";
//return ERR_PARSE_ERROR;
} break ;
}
str + = res ;
} else {
str + = ch ;
}
}
r_token . type = TK_CONSTANT ;
r_token . value = str ;
return OK ;
} break ;
default : {
if ( cchar < = 32 ) {
break ;
}
2018-10-01 16:06:21 +02:00
CharType next_char = ( str_ofs > = expression . length ( ) ) ? 0 : expression [ str_ofs ] ;
if ( _is_number ( cchar ) | | ( cchar = = ' . ' & & _is_number ( next_char ) ) ) {
2018-08-08 22:34:24 +02:00
//a number
String num ;
# define READING_SIGN 0
# define READING_INT 1
# define READING_DEC 2
# define READING_EXP 3
# define READING_DONE 4
int reading = READING_INT ;
CharType c = cchar ;
bool exp_sign = false ;
bool exp_beg = false ;
bool is_float = false ;
while ( true ) {
switch ( reading ) {
case READING_INT : {
2018-10-01 16:06:21 +02:00
if ( _is_number ( c ) ) {
2018-08-08 22:34:24 +02:00
//pass
} else if ( c = = ' . ' ) {
reading = READING_DEC ;
is_float = true ;
} else if ( c = = ' e ' ) {
reading = READING_EXP ;
} else {
reading = READING_DONE ;
}
} break ;
case READING_DEC : {
2018-10-01 16:06:21 +02:00
if ( _is_number ( c ) ) {
2018-08-08 22:34:24 +02:00
} else if ( c = = ' e ' ) {
reading = READING_EXP ;
} else {
reading = READING_DONE ;
}
} break ;
case READING_EXP : {
2018-10-01 16:06:21 +02:00
if ( _is_number ( c ) ) {
2018-08-08 22:34:24 +02:00
exp_beg = true ;
} else if ( ( c = = ' - ' | | c = = ' + ' ) & & ! exp_sign & & ! exp_beg ) {
if ( c = = ' - ' )
is_float = true ;
exp_sign = true ;
} else {
reading = READING_DONE ;
}
} break ;
}
if ( reading = = READING_DONE )
break ;
num + = String : : chr ( c ) ;
c = GET_CHAR ( ) ;
}
str_ofs - - ;
r_token . type = TK_CONSTANT ;
if ( is_float )
r_token . value = num . to_double ( ) ;
else
r_token . value = num . to_int ( ) ;
return OK ;
} else if ( ( cchar > = ' A ' & & cchar < = ' Z ' ) | | ( cchar > = ' a ' & & cchar < = ' z ' ) | | cchar = = ' _ ' ) {
String id ;
bool first = true ;
2018-10-01 16:06:21 +02:00
while ( ( cchar > = ' A ' & & cchar < = ' Z ' ) | | ( cchar > = ' a ' & & cchar < = ' z ' ) | | cchar = = ' _ ' | | ( ! first & & _is_number ( cchar ) ) ) {
2018-08-08 22:34:24 +02:00
id + = String : : chr ( cchar ) ;
cchar = GET_CHAR ( ) ;
first = false ;
}
str_ofs - - ; //go back one
if ( id = = " in " ) {
r_token . type = TK_OP_IN ;
} else if ( id = = " null " ) {
r_token . type = TK_CONSTANT ;
r_token . value = Variant ( ) ;
} else if ( id = = " true " ) {
r_token . type = TK_CONSTANT ;
r_token . value = true ;
} else if ( id = = " false " ) {
r_token . type = TK_CONSTANT ;
r_token . value = false ;
} else if ( id = = " PI " ) {
r_token . type = TK_CONSTANT ;
r_token . value = Math_PI ;
} else if ( id = = " TAU " ) {
r_token . type = TK_CONSTANT ;
r_token . value = Math_TAU ;
} else if ( id = = " INF " ) {
r_token . type = TK_CONSTANT ;
r_token . value = Math_INF ;
} else if ( id = = " NAN " ) {
r_token . type = TK_CONSTANT ;
r_token . value = Math_NAN ;
} else if ( id = = " not " ) {
r_token . type = TK_OP_NOT ;
} else if ( id = = " or " ) {
r_token . type = TK_OP_OR ;
} else if ( id = = " and " ) {
r_token . type = TK_OP_AND ;
} else if ( id = = " self " ) {
r_token . type = TK_SELF ;
} else {
for ( int i = 0 ; i < Variant : : VARIANT_MAX ; i + + ) {
if ( id = = Variant : : get_type_name ( Variant : : Type ( i ) ) ) {
r_token . type = TK_BASIC_TYPE ;
r_token . value = i ;
return OK ;
}
}
BuiltinFunc bifunc = find_function ( id ) ;
if ( bifunc ! = FUNC_MAX ) {
r_token . type = TK_BUILTIN_FUNC ;
r_token . value = bifunc ;
return OK ;
}
r_token . type = TK_IDENTIFIER ;
r_token . value = id ;
}
return OK ;
2018-10-01 16:06:21 +02:00
} else if ( cchar = = ' . ' ) {
// Handled down there as we support '.[0-9]' as numbers above
r_token . type = TK_PERIOD ;
return OK ;
2018-08-08 22:34:24 +02:00
} else {
_set_error ( " Unexpected character. " ) ;
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
}
}
2018-10-01 16:06:21 +02:00
# undef GET_CHAR
2018-08-08 22:34:24 +02:00
}
r_token . type = TK_ERROR ;
return ERR_PARSE_ERROR ;
}
const char * Expression : : token_name [ TK_MAX ] = {
" CURLY BRACKET OPEN " ,
" CURLY BRACKET CLOSE " ,
" BRACKET OPEN " ,
" BRACKET CLOSE " ,
" PARENTHESIS OPEN " ,
" PARENTHESIS CLOSE " ,
" IDENTIFIER " ,
" BUILTIN FUNC " ,
" SELF " ,
" CONSTANT " ,
" BASIC TYPE " ,
" COLON " ,
" COMMA " ,
" PERIOD " ,
" OP IN " ,
" OP EQUAL " ,
" OP NOT EQUAL " ,
" OP LESS " ,
" OP LESS EQUAL " ,
" OP GREATER " ,
" OP GREATER EQUAL " ,
" OP AND " ,
" OP OR " ,
" OP NOT " ,
" OP ADD " ,
" OP SUB " ,
" OP MUL " ,
" OP DIV " ,
" OP MOD " ,
" OP SHIFT LEFT " ,
" OP SHIFT RIGHT " ,
" OP BIT AND " ,
" OP BIT OR " ,
" OP BIT XOR " ,
" OP BIT INVERT " ,
" OP INPUT " ,
" EOF " ,
" ERROR "
} ;
Expression : : ENode * Expression : : _parse_expression ( ) {
Vector < ExpressionNode > expression ;
while ( true ) {
//keep appending stuff to expression
ENode * expr = NULL ;
Token tk ;
_get_token ( tk ) ;
if ( error_set )
return NULL ;
switch ( tk . type ) {
case TK_CURLY_BRACKET_OPEN : {
//a dictionary
DictionaryNode * dn = alloc_node < DictionaryNode > ( ) ;
while ( true ) {
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_CURLY_BRACKET_CLOSE ) {
break ;
}
str_ofs = cofs ; //revert
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
dn - > dict . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
_get_token ( tk ) ;
if ( tk . type ! = TK_COLON ) {
_set_error ( " Expected ':' " ) ;
return NULL ;
}
2019-02-12 21:10:08 +01:00
subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
dn - > dict . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_CURLY_BRACKET_CLOSE ) {
str_ofs = cofs ;
} else {
_set_error ( " Expected ',' or '}' " ) ;
}
}
expr = dn ;
} break ;
case TK_BRACKET_OPEN : {
//an array
ArrayNode * an = alloc_node < ArrayNode > ( ) ;
while ( true ) {
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_BRACKET_CLOSE ) {
break ;
}
str_ofs = cofs ; //revert
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
an - > array . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_BRACKET_CLOSE ) {
str_ofs = cofs ;
} else {
_set_error ( " Expected ',' or ']' " ) ;
}
}
expr = an ;
} break ;
case TK_PARENTHESIS_OPEN : {
//a suexpression
ENode * e = _parse_expression ( ) ;
if ( error_set )
return NULL ;
_get_token ( tk ) ;
if ( tk . type ! = TK_PARENTHESIS_CLOSE ) {
_set_error ( " Expected ')' " ) ;
return NULL ;
}
expr = e ;
} break ;
case TK_IDENTIFIER : {
String identifier = tk . value ;
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_OPEN ) {
//function call
CallNode * func_call = alloc_node < CallNode > ( ) ;
func_call - > method = identifier ;
SelfNode * self_node = alloc_node < SelfNode > ( ) ;
func_call - > base = self_node ;
while ( true ) {
2019-02-12 21:10:08 +01:00
int cofs2 = str_ofs ;
2018-08-08 22:34:24 +02:00
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
break ;
}
2019-02-12 21:10:08 +01:00
str_ofs = cofs2 ; //revert
2018-08-08 22:34:24 +02:00
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
func_call - > arguments . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
2019-02-12 21:10:08 +01:00
cofs2 = str_ofs ;
2018-08-08 22:34:24 +02:00
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
2019-02-12 21:10:08 +01:00
str_ofs = cofs2 ;
2018-08-08 22:34:24 +02:00
} else {
_set_error ( " Expected ',' or ')' " ) ;
}
}
expr = func_call ;
} else {
//named indexing
str_ofs = cofs ;
2018-08-08 22:47:51 +02:00
int input_index = - 1 ;
for ( int i = 0 ; i < input_names . size ( ) ; i + + ) {
if ( input_names [ i ] = = identifier ) {
input_index = i ;
break ;
}
}
if ( input_index ! = - 1 ) {
InputNode * input = alloc_node < InputNode > ( ) ;
input - > index = input_index ;
expr = input ;
} else {
NamedIndexNode * index = alloc_node < NamedIndexNode > ( ) ;
SelfNode * self_node = alloc_node < SelfNode > ( ) ;
index - > base = self_node ;
index - > name = identifier ;
expr = index ;
}
2018-08-08 22:34:24 +02:00
}
} break ;
case TK_INPUT : {
InputNode * input = alloc_node < InputNode > ( ) ;
input - > index = tk . value ;
expr = input ;
} break ;
case TK_SELF : {
SelfNode * self = alloc_node < SelfNode > ( ) ;
expr = self ;
} break ;
case TK_CONSTANT : {
ConstantNode * constant = alloc_node < ConstantNode > ( ) ;
constant - > value = tk . value ;
expr = constant ;
} break ;
case TK_BASIC_TYPE : {
//constructor..
Variant : : Type bt = Variant : : Type ( int ( tk . value ) ) ;
_get_token ( tk ) ;
if ( tk . type ! = TK_PARENTHESIS_OPEN ) {
_set_error ( " Expected '(' " ) ;
return NULL ;
}
ConstructorNode * constructor = alloc_node < ConstructorNode > ( ) ;
constructor - > data_type = bt ;
while ( true ) {
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
break ;
}
str_ofs = cofs ; //revert
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
constructor - > arguments . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
str_ofs = cofs ;
} else {
_set_error ( " Expected ',' or ')' " ) ;
}
}
expr = constructor ;
} break ;
case TK_BUILTIN_FUNC : {
//builtin function
_get_token ( tk ) ;
if ( tk . type ! = TK_PARENTHESIS_OPEN ) {
_set_error ( " Expected '(' " ) ;
return NULL ;
}
BuiltinFuncNode * bifunc = alloc_node < BuiltinFuncNode > ( ) ;
bifunc - > func = BuiltinFunc ( int ( tk . value ) ) ;
while ( true ) {
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
break ;
}
str_ofs = cofs ; //revert
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
bifunc - > arguments . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
str_ofs = cofs ;
} else {
_set_error ( " Expected ',' or ')' " ) ;
}
}
int expected_args = get_func_argument_count ( bifunc - > func ) ;
if ( bifunc - > arguments . size ( ) ! = expected_args ) {
_set_error ( " Builtin func ' " + get_func_name ( bifunc - > func ) + " ' expects " + itos ( expected_args ) + " arguments. " ) ;
}
expr = bifunc ;
} break ;
case TK_OP_SUB : {
ExpressionNode e ;
e . is_op = true ;
e . op = Variant : : OP_NEGATE ;
expression . push_back ( e ) ;
continue ;
} break ;
case TK_OP_NOT : {
ExpressionNode e ;
e . is_op = true ;
e . op = Variant : : OP_NOT ;
expression . push_back ( e ) ;
continue ;
} break ;
default : {
_set_error ( " Expected expression. " ) ;
return NULL ;
} break ;
}
//before going to operators, must check indexing!
while ( true ) {
int cofs2 = str_ofs ;
_get_token ( tk ) ;
if ( error_set )
return NULL ;
bool done = false ;
switch ( tk . type ) {
case TK_BRACKET_OPEN : {
//value indexing
IndexNode * index = alloc_node < IndexNode > ( ) ;
index - > base = expr ;
ENode * what = _parse_expression ( ) ;
if ( ! what )
return NULL ;
index - > index = what ;
_get_token ( tk ) ;
if ( tk . type ! = TK_BRACKET_CLOSE ) {
_set_error ( " Expected ']' at end of index. " ) ;
return NULL ;
}
expr = index ;
} break ;
case TK_PERIOD : {
//named indexing or function call
_get_token ( tk ) ;
if ( tk . type ! = TK_IDENTIFIER ) {
_set_error ( " Expected identifier after '.' " ) ;
return NULL ;
}
StringName identifier = tk . value ;
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_OPEN ) {
//function call
CallNode * func_call = alloc_node < CallNode > ( ) ;
func_call - > method = identifier ;
func_call - > base = expr ;
while ( true ) {
2019-02-12 21:10:08 +01:00
int cofs3 = str_ofs ;
2018-08-08 22:34:24 +02:00
_get_token ( tk ) ;
if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
break ;
}
2019-02-12 21:10:08 +01:00
str_ofs = cofs3 ; //revert
2018-08-08 22:34:24 +02:00
//parse an expression
2019-02-12 21:10:08 +01:00
ENode * subexpr = _parse_expression ( ) ;
if ( ! subexpr )
2018-08-08 22:34:24 +02:00
return NULL ;
2019-02-12 21:10:08 +01:00
func_call - > arguments . push_back ( subexpr ) ;
2018-08-08 22:34:24 +02:00
2019-02-12 21:10:08 +01:00
cofs3 = str_ofs ;
2018-08-08 22:34:24 +02:00
_get_token ( tk ) ;
if ( tk . type = = TK_COMMA ) {
//all good
} else if ( tk . type = = TK_PARENTHESIS_CLOSE ) {
2019-02-12 21:10:08 +01:00
str_ofs = cofs3 ;
2018-08-08 22:34:24 +02:00
} else {
_set_error ( " Expected ',' or ')' " ) ;
}
}
expr = func_call ;
} else {
//named indexing
str_ofs = cofs ;
NamedIndexNode * index = alloc_node < NamedIndexNode > ( ) ;
index - > base = expr ;
index - > name = identifier ;
expr = index ;
}
} break ;
default : {
str_ofs = cofs2 ;
done = true ;
} break ;
}
if ( done )
break ;
}
//push expression
{
ExpressionNode e ;
e . is_op = false ;
e . node = expr ;
expression . push_back ( e ) ;
}
//ok finally look for an operator
int cofs = str_ofs ;
_get_token ( tk ) ;
if ( error_set )
return NULL ;
Variant : : Operator op = Variant : : OP_MAX ;
switch ( tk . type ) {
case TK_OP_IN : op = Variant : : OP_IN ; break ;
case TK_OP_EQUAL : op = Variant : : OP_EQUAL ; break ;
case TK_OP_NOT_EQUAL : op = Variant : : OP_NOT_EQUAL ; break ;
case TK_OP_LESS : op = Variant : : OP_LESS ; break ;
case TK_OP_LESS_EQUAL : op = Variant : : OP_LESS_EQUAL ; break ;
case TK_OP_GREATER : op = Variant : : OP_GREATER ; break ;
case TK_OP_GREATER_EQUAL : op = Variant : : OP_GREATER_EQUAL ; break ;
case TK_OP_AND : op = Variant : : OP_AND ; break ;
case TK_OP_OR : op = Variant : : OP_OR ; break ;
case TK_OP_NOT : op = Variant : : OP_NOT ; break ;
case TK_OP_ADD : op = Variant : : OP_ADD ; break ;
case TK_OP_SUB : op = Variant : : OP_SUBTRACT ; break ;
case TK_OP_MUL : op = Variant : : OP_MULTIPLY ; break ;
case TK_OP_DIV : op = Variant : : OP_DIVIDE ; break ;
case TK_OP_MOD : op = Variant : : OP_MODULE ; break ;
case TK_OP_SHIFT_LEFT : op = Variant : : OP_SHIFT_LEFT ; break ;
case TK_OP_SHIFT_RIGHT : op = Variant : : OP_SHIFT_RIGHT ; break ;
case TK_OP_BIT_AND : op = Variant : : OP_BIT_AND ; break ;
case TK_OP_BIT_OR : op = Variant : : OP_BIT_OR ; break ;
case TK_OP_BIT_XOR : op = Variant : : OP_BIT_XOR ; break ;
case TK_OP_BIT_INVERT : op = Variant : : OP_BIT_NEGATE ; break ;
default : { } ;
}
if ( op = = Variant : : OP_MAX ) { //stop appending stuff
str_ofs = cofs ;
break ;
}
//push operator and go on
{
ExpressionNode e ;
e . is_op = true ;
e . op = op ;
expression . push_back ( e ) ;
}
}
/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
while ( expression . size ( ) > 1 ) {
int next_op = - 1 ;
int min_priority = 0xFFFFF ;
bool is_unary = false ;
for ( int i = 0 ; i < expression . size ( ) ; i + + ) {
if ( ! expression [ i ] . is_op ) {
continue ;
}
int priority ;
bool unary = false ;
switch ( expression [ i ] . op ) {
case Variant : : OP_BIT_NEGATE :
priority = 0 ;
unary = true ;
break ;
case Variant : : OP_NEGATE :
priority = 1 ;
unary = true ;
break ;
case Variant : : OP_MULTIPLY : priority = 2 ; break ;
case Variant : : OP_DIVIDE : priority = 2 ; break ;
case Variant : : OP_MODULE : priority = 2 ; break ;
case Variant : : OP_ADD : priority = 3 ; break ;
case Variant : : OP_SUBTRACT : priority = 3 ; break ;
case Variant : : OP_SHIFT_LEFT : priority = 4 ; break ;
case Variant : : OP_SHIFT_RIGHT : priority = 4 ; break ;
case Variant : : OP_BIT_AND : priority = 5 ; break ;
case Variant : : OP_BIT_XOR : priority = 6 ; break ;
case Variant : : OP_BIT_OR : priority = 7 ; break ;
case Variant : : OP_LESS : priority = 8 ; break ;
case Variant : : OP_LESS_EQUAL : priority = 8 ; break ;
case Variant : : OP_GREATER : priority = 8 ; break ;
case Variant : : OP_GREATER_EQUAL : priority = 8 ; break ;
case Variant : : OP_EQUAL : priority = 8 ; break ;
case Variant : : OP_NOT_EQUAL : priority = 8 ; break ;
case Variant : : OP_IN : priority = 10 ; break ;
case Variant : : OP_NOT :
priority = 11 ;
unary = true ;
break ;
case Variant : : OP_AND : priority = 12 ; break ;
case Variant : : OP_OR : priority = 13 ; break ;
default : {
_set_error ( " Parser bug, invalid operator in expression: " + itos ( expression [ i ] . op ) ) ;
return NULL ;
}
}
if ( priority < min_priority ) {
// < is used for left to right (default)
// <= is used for right to left
next_op = i ;
min_priority = priority ;
is_unary = unary ;
}
}
if ( next_op = = - 1 ) {
_set_error ( " Yet another parser bug.... " ) ;
ERR_FAIL_COND_V ( next_op = = - 1 , NULL ) ;
}
// OK! create operator..
if ( is_unary ) {
int expr_pos = next_op ;
while ( expression [ expr_pos ] . is_op ) {
expr_pos + + ;
if ( expr_pos = = expression . size ( ) ) {
//can happen..
_set_error ( " Unexpected end of expression... " ) ;
return NULL ;
}
}
//consecutively do unary opeators
for ( int i = expr_pos - 1 ; i > = next_op ; i - - ) {
OperatorNode * op = alloc_node < OperatorNode > ( ) ;
op - > op = expression [ i ] . op ;
op - > nodes [ 0 ] = expression [ i + 1 ] . node ;
op - > nodes [ 1 ] = NULL ;
expression . write [ i ] . is_op = false ;
expression . write [ i ] . node = op ;
expression . remove ( i + 1 ) ;
}
} else {
if ( next_op < 1 | | next_op > = ( expression . size ( ) - 1 ) ) {
_set_error ( " Parser bug... " ) ;
ERR_FAIL_V ( NULL ) ;
}
OperatorNode * op = alloc_node < OperatorNode > ( ) ;
op - > op = expression [ next_op ] . op ;
if ( expression [ next_op - 1 ] . is_op ) {
_set_error ( " Parser bug... " ) ;
ERR_FAIL_V ( NULL ) ;
}
if ( expression [ next_op + 1 ] . is_op ) {
// this is not invalid and can really appear
// but it becomes invalid anyway because no binary op
// can be followed by a unary op in a valid combination,
// due to how precedence works, unaries will always disappear first
_set_error ( " Unexpected two consecutive operators. " ) ;
return NULL ;
}
op - > nodes [ 0 ] = expression [ next_op - 1 ] . node ; //expression goes as left
op - > nodes [ 1 ] = expression [ next_op + 1 ] . node ; //next expression goes as right
//replace all 3 nodes by this operator and make it an expression
expression . write [ next_op - 1 ] . node = op ;
expression . remove ( next_op ) ;
expression . remove ( next_op ) ;
}
}
return expression [ 0 ] . node ;
}
bool Expression : : _compile_expression ( ) {
if ( ! expression_dirty )
return error_set ;
if ( nodes ) {
memdelete ( nodes ) ;
nodes = NULL ;
root = NULL ;
}
error_str = String ( ) ;
error_set = false ;
str_ofs = 0 ;
root = _parse_expression ( ) ;
if ( error_set ) {
root = NULL ;
if ( nodes ) {
memdelete ( nodes ) ;
}
nodes = NULL ;
return true ;
}
expression_dirty = false ;
return false ;
}
bool Expression : : _execute ( const Array & p_inputs , Object * p_instance , Expression : : ENode * p_node , Variant & r_ret , String & r_error_str ) {
switch ( p_node - > type ) {
case Expression : : ENode : : TYPE_INPUT : {
const Expression : : InputNode * in = static_cast < const Expression : : InputNode * > ( p_node ) ;
if ( in - > index < 0 | | in - > index > = p_inputs . size ( ) ) {
r_error_str = vformat ( RTR ( " Invalid input %i (not passed) in expression " ) , in - > index ) ;
return true ;
}
r_ret = p_inputs [ in - > index ] ;
} break ;
case Expression : : ENode : : TYPE_CONSTANT : {
const Expression : : ConstantNode * c = static_cast < const Expression : : ConstantNode * > ( p_node ) ;
r_ret = c - > value ;
} break ;
case Expression : : ENode : : TYPE_SELF : {
if ( ! p_instance ) {
r_error_str = RTR ( " self can't be used because instance is null (not passed) " ) ;
return true ;
}
r_ret = p_instance ;
} break ;
case Expression : : ENode : : TYPE_OPERATOR : {
const Expression : : OperatorNode * op = static_cast < const Expression : : OperatorNode * > ( p_node ) ;
Variant a ;
bool ret = _execute ( p_inputs , p_instance , op - > nodes [ 0 ] , a , r_error_str ) ;
if ( ret )
return true ;
Variant b ;
if ( op - > nodes [ 1 ] ) {
2019-02-12 21:10:08 +01:00
ret = _execute ( p_inputs , p_instance , op - > nodes [ 1 ] , b , r_error_str ) ;
2018-08-08 22:34:24 +02:00
if ( ret )
return true ;
}
bool valid = true ;
Variant : : evaluate ( op - > op , a , b , r_ret , valid ) ;
if ( ! valid ) {
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 ( ) ) ) ;
return true ;
}
} break ;
case Expression : : ENode : : TYPE_INDEX : {
const Expression : : IndexNode * index = static_cast < const Expression : : IndexNode * > ( p_node ) ;
Variant base ;
bool ret = _execute ( p_inputs , p_instance , index - > base , base , r_error_str ) ;
if ( ret )
return true ;
Variant idx ;
ret = _execute ( p_inputs , p_instance , index - > index , idx , r_error_str ) ;
if ( ret )
return true ;
bool valid ;
r_ret = base . get ( idx , & valid ) ;
if ( ! valid ) {
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 ( ) ) ) ;
return true ;
}
} break ;
case Expression : : ENode : : TYPE_NAMED_INDEX : {
const Expression : : NamedIndexNode * index = static_cast < const Expression : : NamedIndexNode * > ( p_node ) ;
Variant base ;
bool ret = _execute ( p_inputs , p_instance , index - > base , base , r_error_str ) ;
if ( ret )
return true ;
bool valid ;
r_ret = base . get_named ( index - > name , & valid ) ;
if ( ! valid ) {
2018-08-22 10:58:27 +02:00
r_error_str = vformat ( RTR ( " Invalid named index '%s' for base type %s " ) , String ( index - > name ) , Variant : : get_type_name ( base . get_type ( ) ) ) ;
2018-08-08 22:34:24 +02:00
return true ;
}
} break ;
case Expression : : ENode : : TYPE_ARRAY : {
const Expression : : ArrayNode * array = static_cast < const Expression : : ArrayNode * > ( p_node ) ;
Array arr ;
arr . resize ( array - > array . size ( ) ) ;
for ( int i = 0 ; i < array - > array . size ( ) ; i + + ) {
Variant value ;
bool ret = _execute ( p_inputs , p_instance , array - > array [ i ] , value , r_error_str ) ;
if ( ret )
return true ;
arr [ i ] = value ;
}
r_ret = arr ;
} break ;
case Expression : : ENode : : TYPE_DICTIONARY : {
const Expression : : DictionaryNode * dictionary = static_cast < const Expression : : DictionaryNode * > ( p_node ) ;
Dictionary d ;
for ( int i = 0 ; i < dictionary - > dict . size ( ) ; i + = 2 ) {
Variant key ;
bool ret = _execute ( p_inputs , p_instance , dictionary - > dict [ i + 0 ] , key , r_error_str ) ;
if ( ret )
return true ;
Variant value ;
ret = _execute ( p_inputs , p_instance , dictionary - > dict [ i + 1 ] , value , r_error_str ) ;
if ( ret )
return true ;
d [ key ] = value ;
}
r_ret = d ;
} break ;
case Expression : : ENode : : TYPE_CONSTRUCTOR : {
const Expression : : ConstructorNode * constructor = static_cast < const Expression : : ConstructorNode * > ( p_node ) ;
Vector < Variant > arr ;
Vector < const Variant * > argp ;
arr . resize ( constructor - > arguments . size ( ) ) ;
argp . resize ( constructor - > arguments . size ( ) ) ;
for ( int i = 0 ; i < constructor - > arguments . size ( ) ; i + + ) {
Variant value ;
bool ret = _execute ( p_inputs , p_instance , constructor - > arguments [ i ] , value , r_error_str ) ;
if ( ret )
return true ;
arr . write [ i ] = value ;
argp . write [ i ] = & arr [ i ] ;
}
Variant : : CallError ce ;
r_ret = Variant : : construct ( constructor - > data_type , ( const Variant * * ) argp . ptr ( ) , argp . size ( ) , ce ) ;
if ( ce . error ! = Variant : : CallError : : CALL_OK ) {
r_error_str = vformat ( RTR ( " Invalid arguments to construct '%s' " ) , Variant : : get_type_name ( constructor - > data_type ) ) ;
return true ;
}
} break ;
case Expression : : ENode : : TYPE_BUILTIN_FUNC : {
const Expression : : BuiltinFuncNode * bifunc = static_cast < const Expression : : BuiltinFuncNode * > ( p_node ) ;
Vector < Variant > arr ;
Vector < const Variant * > argp ;
arr . resize ( bifunc - > arguments . size ( ) ) ;
argp . resize ( bifunc - > arguments . size ( ) ) ;
for ( int i = 0 ; i < bifunc - > arguments . size ( ) ; i + + ) {
Variant value ;
bool ret = _execute ( p_inputs , p_instance , bifunc - > arguments [ i ] , value , r_error_str ) ;
if ( ret )
return true ;
arr . write [ i ] = value ;
argp . write [ i ] = & arr [ i ] ;
}
Variant : : CallError ce ;
exec_func ( bifunc - > func , ( const Variant * * ) argp . ptr ( ) , & r_ret , ce , r_error_str ) ;
if ( ce . error ! = Variant : : CallError : : CALL_OK ) {
r_error_str = " Builtin Call Failed. " + r_error_str ;
return true ;
}
} break ;
case Expression : : ENode : : TYPE_CALL : {
const Expression : : CallNode * call = static_cast < const Expression : : CallNode * > ( p_node ) ;
Variant base ;
bool ret = _execute ( p_inputs , p_instance , call - > base , base , r_error_str ) ;
if ( ret )
return true ;
Vector < Variant > arr ;
Vector < const Variant * > argp ;
arr . resize ( call - > arguments . size ( ) ) ;
argp . resize ( call - > arguments . size ( ) ) ;
for ( int i = 0 ; i < call - > arguments . size ( ) ; i + + ) {
Variant value ;
2019-02-12 21:10:08 +01:00
ret = _execute ( p_inputs , p_instance , call - > arguments [ i ] , value , r_error_str ) ;
2018-08-08 22:34:24 +02:00
if ( ret )
return true ;
arr . write [ i ] = value ;
argp . write [ i ] = & arr [ i ] ;
}
Variant : : CallError ce ;
r_ret = base . call ( call - > method , ( const Variant * * ) argp . ptr ( ) , argp . size ( ) , ce ) ;
if ( ce . error ! = Variant : : CallError : : CALL_OK ) {
r_error_str = vformat ( RTR ( " On call to '%s': " ) , String ( call - > method ) ) ;
return true ;
}
} break ;
}
return false ;
}
2018-08-08 22:47:51 +02:00
Error Expression : : parse ( const String & p_expression , const Vector < String > & p_input_names ) {
2018-08-08 22:34:24 +02:00
if ( nodes ) {
memdelete ( nodes ) ;
nodes = NULL ;
root = NULL ;
}
error_str = String ( ) ;
error_set = false ;
str_ofs = 0 ;
2018-08-08 22:47:51 +02:00
input_names = p_input_names ;
2018-08-08 22:34:24 +02:00
expression = p_expression ;
root = _parse_expression ( ) ;
if ( error_set ) {
root = NULL ;
if ( nodes ) {
memdelete ( nodes ) ;
}
nodes = NULL ;
return ERR_INVALID_PARAMETER ;
}
return OK ;
}
Variant Expression : : execute ( Array p_inputs , Object * p_base , bool p_show_error ) {
2018-10-28 11:13:39 +01:00
if ( error_set ) {
ERR_EXPLAIN ( " There was previously a parse error: " + error_str ) ;
ERR_FAIL_V ( Variant ( ) ) ;
}
2018-08-08 22:34:24 +02:00
execution_error = false ;
Variant output ;
String error_txt ;
bool err = _execute ( p_inputs , p_base , root , output , error_txt ) ;
if ( err ) {
execution_error = true ;
error_str = error_txt ;
if ( p_show_error ) {
ERR_EXPLAIN ( error_str ) ;
ERR_FAIL_V ( Variant ( ) ) ;
}
}
return output ;
}
bool Expression : : has_execute_failed ( ) const {
return execution_error ;
}
String Expression : : get_error_text ( ) const {
return error_str ;
}
void Expression : : _bind_methods ( ) {
2018-08-08 22:47:51 +02:00
ClassDB : : bind_method ( D_METHOD ( " parse " , " expression " , " input_names " ) , & Expression : : parse , DEFVAL ( Vector < String > ( ) ) ) ;
2018-08-09 13:50:06 +02:00
ClassDB : : bind_method ( D_METHOD ( " execute " , " inputs " , " base_instance " , " show_error " ) , & Expression : : execute , DEFVAL ( Array ( ) ) , DEFVAL ( Variant ( ) ) , DEFVAL ( true ) ) ;
2018-08-08 22:34:24 +02:00
ClassDB : : bind_method ( D_METHOD ( " has_execute_failed " ) , & Expression : : has_execute_failed ) ;
ClassDB : : bind_method ( D_METHOD ( " get_error_text " ) , & Expression : : get_error_text ) ;
}
2018-12-08 21:07:33 +01:00
Expression : : Expression ( ) :
output_type ( Variant : : NIL ) ,
sequenced ( false ) ,
error_set ( true ) ,
root ( NULL ) ,
nodes ( NULL ) ,
execution_error ( false ) {
2018-08-08 22:34:24 +02:00
}
Expression : : ~ Expression ( ) {
if ( nodes ) {
memdelete ( nodes ) ;
}
}
