You've already forked godot
mirror of
https://github.com/godotengine/godot.git
synced 2025-11-23 15:16:17 +00:00
Create Variant built-in functions.
-Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
This commit is contained in:
reduz
@@ -37,688 +37,6 @@
|
||||
#include "core/os/os.h"
|
||||
#include "core/variant/variant_parser.h"
|
||||
|
||||
const char *Expression::func_name[Expression::FUNC_MAX] = {
|
||||
"sin",
|
||||
"cos",
|
||||
"tan",
|
||||
"sinh",
|
||||
"cosh",
|
||||
"tanh",
|
||||
"asin",
|
||||
"acos",
|
||||
"atan",
|
||||
"atan2",
|
||||
"sqrt",
|
||||
"fmod",
|
||||
"fposmod",
|
||||
"posmod",
|
||||
"floor",
|
||||
"ceil",
|
||||
"round",
|
||||
"abs",
|
||||
"sign",
|
||||
"pow",
|
||||
"log",
|
||||
"exp",
|
||||
"is_nan",
|
||||
"is_inf",
|
||||
"ease",
|
||||
"step_decimals",
|
||||
"stepify",
|
||||
"lerp",
|
||||
"lerp_angle",
|
||||
"inverse_lerp",
|
||||
"range_lerp",
|
||||
"smoothstep",
|
||||
"move_toward",
|
||||
"dectime",
|
||||
"randomize",
|
||||
"randi",
|
||||
"randf",
|
||||
"randf_range",
|
||||
"randi_range",
|
||||
"seed",
|
||||
"rand_seed",
|
||||
"deg2rad",
|
||||
"rad2deg",
|
||||
"linear2db",
|
||||
"db2linear",
|
||||
"polar2cartesian",
|
||||
"cartesian2polar",
|
||||
"wrapi",
|
||||
"wrapf",
|
||||
"max",
|
||||
"min",
|
||||
"clamp",
|
||||
"nearest_po2",
|
||||
"weakref",
|
||||
"convert",
|
||||
"typeof",
|
||||
"type_exists",
|
||||
"char",
|
||||
"ord",
|
||||
"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_RANDI:
|
||||
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_STEP_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_ORD:
|
||||
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;
|
||||
case VAR_TO_BYTES:
|
||||
case BYTES_TO_VAR:
|
||||
case MATH_ATAN2:
|
||||
case MATH_FMOD:
|
||||
case MATH_FPOSMOD:
|
||||
case MATH_POSMOD:
|
||||
case MATH_POW:
|
||||
case MATH_EASE:
|
||||
case MATH_STEPIFY:
|
||||
case MATH_RANDF_RANGE:
|
||||
case MATH_RANDI_RANGE:
|
||||
case MATH_POLAR2CARTESIAN:
|
||||
case MATH_CARTESIAN2POLAR:
|
||||
case LOGIC_MAX:
|
||||
case LOGIC_MIN:
|
||||
case TYPE_CONVERT:
|
||||
case COLORN:
|
||||
return 2;
|
||||
case MATH_LERP:
|
||||
case MATH_LERP_ANGLE:
|
||||
case MATH_INVERSE_LERP:
|
||||
case MATH_SMOOTHSTEP:
|
||||
case MATH_MOVE_TOWARD:
|
||||
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 = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT; \
|
||||
r_error.argument = m_arg; \
|
||||
r_error.expected = Variant::FLOAT; \
|
||||
return; \
|
||||
}
|
||||
|
||||
void Expression::exec_func(BuiltinFunc p_func, const Variant **p_inputs, Variant *r_return, Callable::CallError &r_error, String &r_error_str) {
|
||||
r_error.error = Callable::CallError::CALL_OK;
|
||||
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_POSMOD: {
|
||||
VALIDATE_ARG_NUM(0);
|
||||
VALIDATE_ARG_NUM(1);
|
||||
*r_return = Math::posmod((int)*p_inputs[0], (int)*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::FLOAT) {
|
||||
real_t r = *p_inputs[0];
|
||||
*r_return = Math::abs(r);
|
||||
} else {
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::FLOAT;
|
||||
}
|
||||
} 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::FLOAT) {
|
||||
real_t r = *p_inputs[0];
|
||||
*r_return = r < 0.0 ? -1.0 : (r > 0.0 ? +1.0 : 0.0);
|
||||
} else {
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::FLOAT;
|
||||
}
|
||||
} 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_STEP_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_LERP_ANGLE: {
|
||||
VALIDATE_ARG_NUM(0);
|
||||
VALIDATE_ARG_NUM(1);
|
||||
VALIDATE_ARG_NUM(2);
|
||||
*r_return = Math::lerp_angle((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;
|
||||
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;
|
||||
case MATH_MOVE_TOWARD: {
|
||||
VALIDATE_ARG_NUM(0);
|
||||
VALIDATE_ARG_NUM(1);
|
||||
VALIDATE_ARG_NUM(2);
|
||||
*r_return = Math::move_toward((double)*p_inputs[0], (double)*p_inputs[1], (double)*p_inputs[2]);
|
||||
} break;
|
||||
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_RANDI: {
|
||||
*r_return = Math::rand();
|
||||
} break;
|
||||
case MATH_RANDF: {
|
||||
*r_return = Math::randf();
|
||||
} break;
|
||||
case MATH_RANDF_RANGE: {
|
||||
VALIDATE_ARG_NUM(0);
|
||||
VALIDATE_ARG_NUM(1);
|
||||
*r_return = Math::random((double)*p_inputs[0], (double)*p_inputs[1]);
|
||||
} break;
|
||||
case MATH_RANDI_RANGE: {
|
||||
VALIDATE_ARG_NUM(0);
|
||||
VALIDATE_ARG_NUM(1);
|
||||
*r_return = Math::random((int)*p_inputs[0], (int)*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 = Callable::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 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 = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::INT;
|
||||
return;
|
||||
|
||||
} else {
|
||||
Variant::construct(Variant::Type(type), *r_return, 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: {
|
||||
char32_t result[2] = { *p_inputs[0], 0 };
|
||||
|
||||
*r_return = String(result);
|
||||
|
||||
} break;
|
||||
case TEXT_ORD: {
|
||||
if (p_inputs[0]->get_type() != Variant::STRING) {
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::STRING;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
String str = *p_inputs[0];
|
||||
|
||||
if (str.length() != 1) {
|
||||
r_error_str = RTR("Expected a string of length 1 (a character).");
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::STRING;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
*r_return = str.get(0);
|
||||
|
||||
} 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: {
|
||||
String str = *p_inputs[0];
|
||||
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 = Callable::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 = Callable::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: {
|
||||
PackedByteArray barr;
|
||||
bool full_objects = *p_inputs[1];
|
||||
int len;
|
||||
Error err = encode_variant(*p_inputs[0], nullptr, len, full_objects);
|
||||
if (err) {
|
||||
r_error.error = Callable::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);
|
||||
{
|
||||
uint8_t *w = barr.ptrw();
|
||||
encode_variant(*p_inputs[0], w, len, full_objects);
|
||||
}
|
||||
*r_return = barr;
|
||||
} break;
|
||||
case BYTES_TO_VAR: {
|
||||
if (p_inputs[0]->get_type() != Variant::PACKED_BYTE_ARRAY) {
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::PACKED_BYTE_ARRAY;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
PackedByteArray varr = *p_inputs[0];
|
||||
bool allow_objects = *p_inputs[1];
|
||||
Variant ret;
|
||||
{
|
||||
const uint8_t *r = varr.ptr();
|
||||
Error err = decode_variant(ret, r, varr.size(), nullptr, allow_objects);
|
||||
if (err != OK) {
|
||||
r_error_str = RTR("Not enough bytes for decoding bytes, or invalid format.");
|
||||
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
|
||||
r_error.argument = 0;
|
||||
r_error.expected = Variant::PACKED_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: {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
////////
|
||||
|
||||
static bool _is_number(char32_t c) {
|
||||
return (c >= '0' && c <= '9');
|
||||
}
|
||||
@@ -1092,18 +410,9 @@ Error Expression::_get_token(Token &r_token) {
|
||||
} 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) {
|
||||
if (Variant::has_builtin_func(id)) {
|
||||
r_token.type = TK_BUILTIN_FUNC;
|
||||
r_token.value = bifunc;
|
||||
r_token.value = id;
|
||||
return OK;
|
||||
}
|
||||
|
||||
@@ -1401,6 +710,8 @@ Expression::ENode *Expression::_parse_expression() {
|
||||
case TK_BUILTIN_FUNC: {
|
||||
//builtin function
|
||||
|
||||
StringName func = tk.value;
|
||||
|
||||
_get_token(tk);
|
||||
if (tk.type != TK_PARENTHESIS_OPEN) {
|
||||
_set_error("Expected '('");
|
||||
@@ -1408,7 +719,7 @@ Expression::ENode *Expression::_parse_expression() {
|
||||
}
|
||||
|
||||
BuiltinFuncNode *bifunc = alloc_node<BuiltinFuncNode>();
|
||||
bifunc->func = BuiltinFunc(int(tk.value));
|
||||
bifunc->func = func;
|
||||
|
||||
while (true) {
|
||||
int cofs = str_ofs;
|
||||
@@ -1436,9 +747,11 @@ Expression::ENode *Expression::_parse_expression() {
|
||||
}
|
||||
}
|
||||
|
||||
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.");
|
||||
if (!Variant::is_builtin_func_vararg(bifunc->func)) {
|
||||
int expected_args = Variant::get_builtin_func_argument_count(bifunc->func);
|
||||
if (expected_args != bifunc->arguments.size()) {
|
||||
_set_error("Builtin func '" + String(bifunc->func) + "' expects " + itos(expected_args) + " arguments.");
|
||||
}
|
||||
}
|
||||
|
||||
expr = bifunc;
|
||||
@@ -2047,11 +1360,11 @@ bool Expression::_execute(const Array &p_inputs, Object *p_instance, Expression:
|
||||
argp.write[i] = &arr[i];
|
||||
}
|
||||
|
||||
r_ret = Variant(); //may not return anything
|
||||
Callable::CallError ce;
|
||||
exec_func(bifunc->func, (const Variant **)argp.ptr(), &r_ret, ce, r_error_str);
|
||||
|
||||
Variant::call_builtin_func(bifunc->func, &r_ret, (const Variant **)argp.ptr(), argp.size(), ce);
|
||||
if (ce.error != Callable::CallError::CALL_OK) {
|
||||
r_error_str = "Builtin Call Failed. " + r_error_str;
|
||||
r_error_str = "Builtin Call Failed. " + Variant::get_call_error_text(bifunc->func, (const Variant **)argp.ptr(), argp.size(), ce);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user