mirror of
https://github.com/godotengine/godot.git
synced 2024-12-27 11:24:59 +08:00
7ca038effa
When the types are validated at compile time, this type of call runs faster. It is already used for instance methods, this adds this optimization to native static methods as well.
581 lines
18 KiB
C++
581 lines
18 KiB
C++
/**************************************************************************/
|
|
/* gdscript_function.h */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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. */
|
|
/**************************************************************************/
|
|
|
|
#ifndef GDSCRIPT_FUNCTION_H
|
|
#define GDSCRIPT_FUNCTION_H
|
|
|
|
#include "gdscript_utility_functions.h"
|
|
|
|
#include "core/object/ref_counted.h"
|
|
#include "core/object/script_language.h"
|
|
#include "core/os/thread.h"
|
|
#include "core/string/string_name.h"
|
|
#include "core/templates/pair.h"
|
|
#include "core/templates/self_list.h"
|
|
#include "core/variant/variant.h"
|
|
|
|
class GDScriptInstance;
|
|
class GDScript;
|
|
|
|
class GDScriptDataType {
|
|
public:
|
|
Vector<GDScriptDataType> container_element_types;
|
|
|
|
enum Kind {
|
|
UNINITIALIZED,
|
|
BUILTIN,
|
|
NATIVE,
|
|
SCRIPT,
|
|
GDSCRIPT,
|
|
};
|
|
|
|
Kind kind = UNINITIALIZED;
|
|
|
|
bool has_type = false;
|
|
Variant::Type builtin_type = Variant::NIL;
|
|
StringName native_type;
|
|
Script *script_type = nullptr;
|
|
Ref<Script> script_type_ref;
|
|
|
|
bool is_type(const Variant &p_variant, bool p_allow_implicit_conversion = false) const {
|
|
if (!has_type) {
|
|
return true; // Can't type check
|
|
}
|
|
|
|
switch (kind) {
|
|
case UNINITIALIZED:
|
|
break;
|
|
case BUILTIN: {
|
|
Variant::Type var_type = p_variant.get_type();
|
|
bool valid = builtin_type == var_type;
|
|
if (valid && builtin_type == Variant::ARRAY && has_container_element_type(0)) {
|
|
Array array = p_variant;
|
|
if (array.is_typed()) {
|
|
const GDScriptDataType &elem_type = container_element_types[0];
|
|
Variant::Type array_builtin_type = (Variant::Type)array.get_typed_builtin();
|
|
StringName array_native_type = array.get_typed_class_name();
|
|
Ref<Script> array_script_type_ref = array.get_typed_script();
|
|
|
|
if (array_script_type_ref.is_valid()) {
|
|
valid = (elem_type.kind == SCRIPT || elem_type.kind == GDSCRIPT) && elem_type.script_type == array_script_type_ref.ptr();
|
|
} else if (array_native_type != StringName()) {
|
|
valid = elem_type.kind == NATIVE && elem_type.native_type == array_native_type;
|
|
} else {
|
|
valid = elem_type.kind == BUILTIN && elem_type.builtin_type == array_builtin_type;
|
|
}
|
|
} else {
|
|
valid = false;
|
|
}
|
|
} else if (!valid && p_allow_implicit_conversion) {
|
|
valid = Variant::can_convert_strict(var_type, builtin_type);
|
|
}
|
|
return valid;
|
|
} break;
|
|
case NATIVE: {
|
|
if (p_variant.get_type() == Variant::NIL) {
|
|
return true;
|
|
}
|
|
if (p_variant.get_type() != Variant::OBJECT) {
|
|
return false;
|
|
}
|
|
|
|
bool was_freed = false;
|
|
Object *obj = p_variant.get_validated_object_with_check(was_freed);
|
|
if (!obj) {
|
|
return !was_freed;
|
|
}
|
|
|
|
if (!ClassDB::is_parent_class(obj->get_class_name(), native_type)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
} break;
|
|
case SCRIPT:
|
|
case GDSCRIPT: {
|
|
if (p_variant.get_type() == Variant::NIL) {
|
|
return true;
|
|
}
|
|
if (p_variant.get_type() != Variant::OBJECT) {
|
|
return false;
|
|
}
|
|
|
|
bool was_freed = false;
|
|
Object *obj = p_variant.get_validated_object_with_check(was_freed);
|
|
if (!obj) {
|
|
return !was_freed;
|
|
}
|
|
|
|
Ref<Script> base = obj && obj->get_script_instance() ? obj->get_script_instance()->get_script() : nullptr;
|
|
bool valid = false;
|
|
while (base.is_valid()) {
|
|
if (base == script_type) {
|
|
valid = true;
|
|
break;
|
|
}
|
|
base = base->get_base_script();
|
|
}
|
|
return valid;
|
|
} break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool can_contain_object() const {
|
|
if (has_type && kind == BUILTIN) {
|
|
switch (builtin_type) {
|
|
case Variant::ARRAY:
|
|
if (has_container_element_type(0)) {
|
|
return container_element_types[0].can_contain_object();
|
|
}
|
|
return true;
|
|
case Variant::DICTIONARY:
|
|
case Variant::NIL:
|
|
case Variant::OBJECT:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void set_container_element_type(int p_index, const GDScriptDataType &p_element_type) {
|
|
ERR_FAIL_COND(p_index < 0);
|
|
while (p_index >= container_element_types.size()) {
|
|
container_element_types.push_back(GDScriptDataType());
|
|
}
|
|
container_element_types.write[p_index] = GDScriptDataType(p_element_type);
|
|
}
|
|
|
|
GDScriptDataType get_container_element_type(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, container_element_types.size(), GDScriptDataType());
|
|
return container_element_types[p_index];
|
|
}
|
|
|
|
GDScriptDataType get_container_element_type_or_variant(int p_index) const {
|
|
if (p_index < 0 || p_index >= container_element_types.size()) {
|
|
return GDScriptDataType();
|
|
}
|
|
return container_element_types[p_index];
|
|
}
|
|
|
|
bool has_container_element_type(int p_index) const {
|
|
return p_index >= 0 && p_index < container_element_types.size();
|
|
}
|
|
|
|
bool has_container_element_types() const {
|
|
return !container_element_types.is_empty();
|
|
}
|
|
|
|
GDScriptDataType() = default;
|
|
|
|
void operator=(const GDScriptDataType &p_other) {
|
|
kind = p_other.kind;
|
|
has_type = p_other.has_type;
|
|
builtin_type = p_other.builtin_type;
|
|
native_type = p_other.native_type;
|
|
script_type = p_other.script_type;
|
|
script_type_ref = p_other.script_type_ref;
|
|
container_element_types = p_other.container_element_types;
|
|
}
|
|
|
|
GDScriptDataType(const GDScriptDataType &p_other) {
|
|
*this = p_other;
|
|
}
|
|
|
|
~GDScriptDataType() {}
|
|
};
|
|
|
|
class GDScriptFunction {
|
|
public:
|
|
enum Opcode {
|
|
OPCODE_OPERATOR,
|
|
OPCODE_OPERATOR_VALIDATED,
|
|
OPCODE_TYPE_TEST_BUILTIN,
|
|
OPCODE_TYPE_TEST_ARRAY,
|
|
OPCODE_TYPE_TEST_NATIVE,
|
|
OPCODE_TYPE_TEST_SCRIPT,
|
|
OPCODE_SET_KEYED,
|
|
OPCODE_SET_KEYED_VALIDATED,
|
|
OPCODE_SET_INDEXED_VALIDATED,
|
|
OPCODE_GET_KEYED,
|
|
OPCODE_GET_KEYED_VALIDATED,
|
|
OPCODE_GET_INDEXED_VALIDATED,
|
|
OPCODE_SET_NAMED,
|
|
OPCODE_SET_NAMED_VALIDATED,
|
|
OPCODE_GET_NAMED,
|
|
OPCODE_GET_NAMED_VALIDATED,
|
|
OPCODE_SET_MEMBER,
|
|
OPCODE_GET_MEMBER,
|
|
OPCODE_SET_STATIC_VARIABLE, // Only for GDScript.
|
|
OPCODE_GET_STATIC_VARIABLE, // Only for GDScript.
|
|
OPCODE_ASSIGN,
|
|
OPCODE_ASSIGN_NULL,
|
|
OPCODE_ASSIGN_TRUE,
|
|
OPCODE_ASSIGN_FALSE,
|
|
OPCODE_ASSIGN_TYPED_BUILTIN,
|
|
OPCODE_ASSIGN_TYPED_ARRAY,
|
|
OPCODE_ASSIGN_TYPED_NATIVE,
|
|
OPCODE_ASSIGN_TYPED_SCRIPT,
|
|
OPCODE_CAST_TO_BUILTIN,
|
|
OPCODE_CAST_TO_NATIVE,
|
|
OPCODE_CAST_TO_SCRIPT,
|
|
OPCODE_CONSTRUCT, // Only for basic types!
|
|
OPCODE_CONSTRUCT_VALIDATED, // Only for basic types!
|
|
OPCODE_CONSTRUCT_ARRAY,
|
|
OPCODE_CONSTRUCT_TYPED_ARRAY,
|
|
OPCODE_CONSTRUCT_DICTIONARY,
|
|
OPCODE_CALL,
|
|
OPCODE_CALL_RETURN,
|
|
OPCODE_CALL_ASYNC,
|
|
OPCODE_CALL_UTILITY,
|
|
OPCODE_CALL_UTILITY_VALIDATED,
|
|
OPCODE_CALL_GDSCRIPT_UTILITY,
|
|
OPCODE_CALL_BUILTIN_TYPE_VALIDATED,
|
|
OPCODE_CALL_SELF_BASE,
|
|
OPCODE_CALL_METHOD_BIND,
|
|
OPCODE_CALL_METHOD_BIND_RET,
|
|
OPCODE_CALL_BUILTIN_STATIC,
|
|
OPCODE_CALL_NATIVE_STATIC,
|
|
OPCODE_CALL_NATIVE_STATIC_VALIDATED_RETURN,
|
|
OPCODE_CALL_NATIVE_STATIC_VALIDATED_NO_RETURN,
|
|
OPCODE_CALL_METHOD_BIND_VALIDATED_RETURN,
|
|
OPCODE_CALL_METHOD_BIND_VALIDATED_NO_RETURN,
|
|
OPCODE_AWAIT,
|
|
OPCODE_AWAIT_RESUME,
|
|
OPCODE_CREATE_LAMBDA,
|
|
OPCODE_CREATE_SELF_LAMBDA,
|
|
OPCODE_JUMP,
|
|
OPCODE_JUMP_IF,
|
|
OPCODE_JUMP_IF_NOT,
|
|
OPCODE_JUMP_TO_DEF_ARGUMENT,
|
|
OPCODE_JUMP_IF_SHARED,
|
|
OPCODE_RETURN,
|
|
OPCODE_RETURN_TYPED_BUILTIN,
|
|
OPCODE_RETURN_TYPED_ARRAY,
|
|
OPCODE_RETURN_TYPED_NATIVE,
|
|
OPCODE_RETURN_TYPED_SCRIPT,
|
|
OPCODE_ITERATE_BEGIN,
|
|
OPCODE_ITERATE_BEGIN_INT,
|
|
OPCODE_ITERATE_BEGIN_FLOAT,
|
|
OPCODE_ITERATE_BEGIN_VECTOR2,
|
|
OPCODE_ITERATE_BEGIN_VECTOR2I,
|
|
OPCODE_ITERATE_BEGIN_VECTOR3,
|
|
OPCODE_ITERATE_BEGIN_VECTOR3I,
|
|
OPCODE_ITERATE_BEGIN_STRING,
|
|
OPCODE_ITERATE_BEGIN_DICTIONARY,
|
|
OPCODE_ITERATE_BEGIN_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_BYTE_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_INT32_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_INT64_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_FLOAT32_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_FLOAT64_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_STRING_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_VECTOR2_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_VECTOR3_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_PACKED_COLOR_ARRAY,
|
|
OPCODE_ITERATE_BEGIN_OBJECT,
|
|
OPCODE_ITERATE,
|
|
OPCODE_ITERATE_INT,
|
|
OPCODE_ITERATE_FLOAT,
|
|
OPCODE_ITERATE_VECTOR2,
|
|
OPCODE_ITERATE_VECTOR2I,
|
|
OPCODE_ITERATE_VECTOR3,
|
|
OPCODE_ITERATE_VECTOR3I,
|
|
OPCODE_ITERATE_STRING,
|
|
OPCODE_ITERATE_DICTIONARY,
|
|
OPCODE_ITERATE_ARRAY,
|
|
OPCODE_ITERATE_PACKED_BYTE_ARRAY,
|
|
OPCODE_ITERATE_PACKED_INT32_ARRAY,
|
|
OPCODE_ITERATE_PACKED_INT64_ARRAY,
|
|
OPCODE_ITERATE_PACKED_FLOAT32_ARRAY,
|
|
OPCODE_ITERATE_PACKED_FLOAT64_ARRAY,
|
|
OPCODE_ITERATE_PACKED_STRING_ARRAY,
|
|
OPCODE_ITERATE_PACKED_VECTOR2_ARRAY,
|
|
OPCODE_ITERATE_PACKED_VECTOR3_ARRAY,
|
|
OPCODE_ITERATE_PACKED_COLOR_ARRAY,
|
|
OPCODE_ITERATE_OBJECT,
|
|
OPCODE_STORE_GLOBAL,
|
|
OPCODE_STORE_NAMED_GLOBAL,
|
|
OPCODE_TYPE_ADJUST_BOOL,
|
|
OPCODE_TYPE_ADJUST_INT,
|
|
OPCODE_TYPE_ADJUST_FLOAT,
|
|
OPCODE_TYPE_ADJUST_STRING,
|
|
OPCODE_TYPE_ADJUST_VECTOR2,
|
|
OPCODE_TYPE_ADJUST_VECTOR2I,
|
|
OPCODE_TYPE_ADJUST_RECT2,
|
|
OPCODE_TYPE_ADJUST_RECT2I,
|
|
OPCODE_TYPE_ADJUST_VECTOR3,
|
|
OPCODE_TYPE_ADJUST_VECTOR3I,
|
|
OPCODE_TYPE_ADJUST_TRANSFORM2D,
|
|
OPCODE_TYPE_ADJUST_VECTOR4,
|
|
OPCODE_TYPE_ADJUST_VECTOR4I,
|
|
OPCODE_TYPE_ADJUST_PLANE,
|
|
OPCODE_TYPE_ADJUST_QUATERNION,
|
|
OPCODE_TYPE_ADJUST_AABB,
|
|
OPCODE_TYPE_ADJUST_BASIS,
|
|
OPCODE_TYPE_ADJUST_TRANSFORM3D,
|
|
OPCODE_TYPE_ADJUST_PROJECTION,
|
|
OPCODE_TYPE_ADJUST_COLOR,
|
|
OPCODE_TYPE_ADJUST_STRING_NAME,
|
|
OPCODE_TYPE_ADJUST_NODE_PATH,
|
|
OPCODE_TYPE_ADJUST_RID,
|
|
OPCODE_TYPE_ADJUST_OBJECT,
|
|
OPCODE_TYPE_ADJUST_CALLABLE,
|
|
OPCODE_TYPE_ADJUST_SIGNAL,
|
|
OPCODE_TYPE_ADJUST_DICTIONARY,
|
|
OPCODE_TYPE_ADJUST_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_BYTE_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_INT32_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_INT64_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_FLOAT32_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_FLOAT64_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_STRING_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_VECTOR2_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_VECTOR3_ARRAY,
|
|
OPCODE_TYPE_ADJUST_PACKED_COLOR_ARRAY,
|
|
OPCODE_ASSERT,
|
|
OPCODE_BREAKPOINT,
|
|
OPCODE_LINE,
|
|
OPCODE_END
|
|
};
|
|
|
|
enum Address {
|
|
ADDR_BITS = 24,
|
|
ADDR_MASK = ((1 << ADDR_BITS) - 1),
|
|
ADDR_TYPE_MASK = ~ADDR_MASK,
|
|
ADDR_TYPE_STACK = 0,
|
|
ADDR_TYPE_CONSTANT = 1,
|
|
ADDR_TYPE_MEMBER = 2,
|
|
ADDR_TYPE_MAX = 3,
|
|
};
|
|
|
|
enum FixedAddresses {
|
|
ADDR_STACK_SELF = 0,
|
|
ADDR_STACK_CLASS = 1,
|
|
ADDR_STACK_NIL = 2,
|
|
FIXED_ADDRESSES_MAX = 3,
|
|
ADDR_SELF = ADDR_STACK_SELF | (ADDR_TYPE_STACK << ADDR_BITS),
|
|
ADDR_CLASS = ADDR_STACK_CLASS | (ADDR_TYPE_STACK << ADDR_BITS),
|
|
ADDR_NIL = ADDR_STACK_NIL | (ADDR_TYPE_STACK << ADDR_BITS),
|
|
};
|
|
|
|
struct StackDebug {
|
|
int line;
|
|
int pos;
|
|
bool added;
|
|
StringName identifier;
|
|
};
|
|
|
|
private:
|
|
friend class GDScript;
|
|
friend class GDScriptCompiler;
|
|
friend class GDScriptByteCodeGenerator;
|
|
friend class GDScriptLanguage;
|
|
|
|
StringName name;
|
|
StringName source;
|
|
bool _static = false;
|
|
Vector<GDScriptDataType> argument_types;
|
|
GDScriptDataType return_type;
|
|
MethodInfo method_info;
|
|
Variant rpc_config;
|
|
|
|
GDScript *_script = nullptr;
|
|
int _initial_line = 0;
|
|
int _argument_count = 0;
|
|
int _stack_size = 0;
|
|
int _instruction_args_size = 0;
|
|
|
|
SelfList<GDScriptFunction> function_list{ this };
|
|
mutable Variant nil;
|
|
HashMap<int, Variant::Type> temporary_slots;
|
|
List<StackDebug> stack_debug;
|
|
|
|
Vector<int> code;
|
|
Vector<int> default_arguments;
|
|
Vector<Variant> constants;
|
|
Vector<StringName> global_names;
|
|
Vector<Variant::ValidatedOperatorEvaluator> operator_funcs;
|
|
Vector<Variant::ValidatedSetter> setters;
|
|
Vector<Variant::ValidatedGetter> getters;
|
|
Vector<Variant::ValidatedKeyedSetter> keyed_setters;
|
|
Vector<Variant::ValidatedKeyedGetter> keyed_getters;
|
|
Vector<Variant::ValidatedIndexedSetter> indexed_setters;
|
|
Vector<Variant::ValidatedIndexedGetter> indexed_getters;
|
|
Vector<Variant::ValidatedBuiltInMethod> builtin_methods;
|
|
Vector<Variant::ValidatedConstructor> constructors;
|
|
Vector<Variant::ValidatedUtilityFunction> utilities;
|
|
Vector<GDScriptUtilityFunctions::FunctionPtr> gds_utilities;
|
|
Vector<MethodBind *> methods;
|
|
Vector<GDScriptFunction *> lambdas;
|
|
|
|
int _code_size = 0;
|
|
int _default_arg_count = 0;
|
|
int _constant_count = 0;
|
|
int _global_names_count = 0;
|
|
int _operator_funcs_count = 0;
|
|
int _setters_count = 0;
|
|
int _getters_count = 0;
|
|
int _keyed_setters_count = 0;
|
|
int _keyed_getters_count = 0;
|
|
int _indexed_setters_count = 0;
|
|
int _indexed_getters_count = 0;
|
|
int _builtin_methods_count = 0;
|
|
int _constructors_count = 0;
|
|
int _utilities_count = 0;
|
|
int _gds_utilities_count = 0;
|
|
int _methods_count = 0;
|
|
int _lambdas_count = 0;
|
|
|
|
int *_code_ptr = nullptr;
|
|
const int *_default_arg_ptr = nullptr;
|
|
mutable Variant *_constants_ptr = nullptr;
|
|
const StringName *_global_names_ptr = nullptr;
|
|
const Variant::ValidatedOperatorEvaluator *_operator_funcs_ptr = nullptr;
|
|
const Variant::ValidatedSetter *_setters_ptr = nullptr;
|
|
const Variant::ValidatedGetter *_getters_ptr = nullptr;
|
|
const Variant::ValidatedKeyedSetter *_keyed_setters_ptr = nullptr;
|
|
const Variant::ValidatedKeyedGetter *_keyed_getters_ptr = nullptr;
|
|
const Variant::ValidatedIndexedSetter *_indexed_setters_ptr = nullptr;
|
|
const Variant::ValidatedIndexedGetter *_indexed_getters_ptr = nullptr;
|
|
const Variant::ValidatedBuiltInMethod *_builtin_methods_ptr = nullptr;
|
|
const Variant::ValidatedConstructor *_constructors_ptr = nullptr;
|
|
const Variant::ValidatedUtilityFunction *_utilities_ptr = nullptr;
|
|
const GDScriptUtilityFunctions::FunctionPtr *_gds_utilities_ptr = nullptr;
|
|
MethodBind **_methods_ptr = nullptr;
|
|
GDScriptFunction **_lambdas_ptr = nullptr;
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
CharString func_cname;
|
|
const char *_func_cname = nullptr;
|
|
|
|
Vector<String> operator_names;
|
|
Vector<String> setter_names;
|
|
Vector<String> getter_names;
|
|
Vector<String> builtin_methods_names;
|
|
Vector<String> constructors_names;
|
|
Vector<String> utilities_names;
|
|
Vector<String> gds_utilities_names;
|
|
|
|
struct Profile {
|
|
StringName signature;
|
|
SafeNumeric<uint64_t> call_count;
|
|
SafeNumeric<uint64_t> self_time;
|
|
SafeNumeric<uint64_t> total_time;
|
|
SafeNumeric<uint64_t> frame_call_count;
|
|
SafeNumeric<uint64_t> frame_self_time;
|
|
SafeNumeric<uint64_t> frame_total_time;
|
|
uint64_t last_frame_call_count = 0;
|
|
uint64_t last_frame_self_time = 0;
|
|
uint64_t last_frame_total_time = 0;
|
|
typedef struct NativeProfile {
|
|
uint64_t call_count;
|
|
uint64_t total_time;
|
|
String signature;
|
|
} NativeProfile;
|
|
HashMap<String, NativeProfile> native_calls;
|
|
HashMap<String, NativeProfile> last_native_calls;
|
|
} profile;
|
|
#endif
|
|
|
|
_FORCE_INLINE_ String _get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const;
|
|
Variant _get_default_variant_for_data_type(const GDScriptDataType &p_data_type);
|
|
|
|
public:
|
|
static constexpr int MAX_CALL_DEPTH = 2048; // Limit to try to avoid crash because of a stack overflow.
|
|
|
|
struct CallState {
|
|
GDScript *script = nullptr;
|
|
GDScriptInstance *instance = nullptr;
|
|
#ifdef DEBUG_ENABLED
|
|
StringName function_name;
|
|
String script_path;
|
|
#endif
|
|
Vector<uint8_t> stack;
|
|
int stack_size = 0;
|
|
uint32_t alloca_size = 0;
|
|
int ip = 0;
|
|
int line = 0;
|
|
int defarg = 0;
|
|
Variant result;
|
|
};
|
|
|
|
_FORCE_INLINE_ StringName get_name() const { return name; }
|
|
_FORCE_INLINE_ StringName get_source() const { return source; }
|
|
_FORCE_INLINE_ GDScript *get_script() const { return _script; }
|
|
_FORCE_INLINE_ bool is_static() const { return _static; }
|
|
_FORCE_INLINE_ MethodInfo get_method_info() const { return method_info; }
|
|
_FORCE_INLINE_ int get_argument_count() const { return _argument_count; }
|
|
_FORCE_INLINE_ Variant get_rpc_config() const { return rpc_config; }
|
|
_FORCE_INLINE_ int get_max_stack_size() const { return _stack_size; }
|
|
|
|
Variant get_constant(int p_idx) const;
|
|
StringName get_global_name(int p_idx) const;
|
|
|
|
Variant call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Callable::CallError &r_err, CallState *p_state = nullptr);
|
|
void debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const;
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
void _profile_native_call(uint64_t p_t_taken, const String &p_function_name, const String &p_instance_class_name = String());
|
|
void disassemble(const Vector<String> &p_code_lines) const;
|
|
#endif
|
|
|
|
GDScriptFunction();
|
|
~GDScriptFunction();
|
|
};
|
|
|
|
class GDScriptFunctionState : public RefCounted {
|
|
GDCLASS(GDScriptFunctionState, RefCounted);
|
|
friend class GDScriptFunction;
|
|
GDScriptFunction *function = nullptr;
|
|
GDScriptFunction::CallState state;
|
|
Variant _signal_callback(const Variant **p_args, int p_argcount, Callable::CallError &r_error);
|
|
Ref<GDScriptFunctionState> first_state;
|
|
|
|
SelfList<GDScriptFunctionState> scripts_list;
|
|
SelfList<GDScriptFunctionState> instances_list;
|
|
|
|
protected:
|
|
static void _bind_methods();
|
|
|
|
public:
|
|
bool is_valid(bool p_extended_check = false) const;
|
|
Variant resume(const Variant &p_arg = Variant());
|
|
|
|
void _clear_stack();
|
|
void _clear_connections();
|
|
|
|
GDScriptFunctionState();
|
|
~GDScriptFunctionState();
|
|
};
|
|
|
|
#endif // GDSCRIPT_FUNCTION_H
|