summaryrefslogtreecommitdiffstats
path: root/core/object/object.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'core/object/object.cpp')
-rw-r--r--core/object/object.cpp134
1 files changed, 118 insertions, 16 deletions
diff --git a/core/object/object.cpp b/core/object/object.cpp
index 3fd7fe36e0..056334c8e1 100644
--- a/core/object/object.cpp
+++ b/core/object/object.cpp
@@ -31,6 +31,7 @@
#include "object.h"
#include "core/core_string_names.h"
+#include "core/extension/gdextension_manager.h"
#include "core/io/resource.h"
#include "core/object/class_db.h"
#include "core/object/message_queue.h"
@@ -616,7 +617,7 @@ void Object::get_method_list(List<MethodInfo> *p_list) const {
Variant Object::_call_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
if (p_argcount < 1) {
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
- r_error.argument = 0;
+ r_error.expected = 1;
return Variant();
}
@@ -635,7 +636,7 @@ Variant Object::_call_bind(const Variant **p_args, int p_argcount, Callable::Cal
Variant Object::_call_deferred_bind(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
if (p_argcount < 1) {
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
- r_error.argument = 0;
+ r_error.expected = 1;
return Variant();
}
@@ -665,8 +666,16 @@ bool Object::has_method(const StringName &p_method) const {
}
MethodBind *method = ClassDB::get_method(get_class_name(), p_method);
+ if (method != nullptr) {
+ return true;
+ }
- return method != nullptr;
+ const Script *scr = Object::cast_to<Script>(this);
+ if (scr != nullptr) {
+ return scr->has_static_method(p_method);
+ }
+
+ return false;
}
Variant Object::getvar(const Variant &p_key, bool *r_valid) const {
@@ -714,12 +723,11 @@ Variant Object::callp(const StringName &p_method, const Variant **p_args, int p_
//free must be here, before anything, always ready
#ifdef DEBUG_ENABLED
if (p_argcount != 0) {
- r_error.argument = 0;
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
+ r_error.expected = 0;
return Variant();
}
if (Object::cast_to<RefCounted>(this)) {
- r_error.argument = 0;
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
ERR_FAIL_V_MSG(Variant(), "Can't 'free' a reference.");
}
@@ -880,7 +888,10 @@ void Object::set_script(const Variant &p_script) {
}
Ref<Script> s = p_script;
- ERR_FAIL_COND_MSG(s.is_null() && !p_script.is_null(), "Invalid parameter, it should be a reference to a valid script (or null).");
+ if (!p_script.is_null()) {
+ ERR_FAIL_COND_MSG(s.is_null(), "Cannot set object script. Parameter should be null or a reference to a valid script.");
+ ERR_FAIL_COND_MSG(s->is_abstract(), vformat("Cannot set object script. Script '%s' should not be abstract.", s->get_path()));
+ }
script = p_script;
@@ -1032,14 +1043,17 @@ struct _ObjectSignalDisconnectData {
};
Error Object::_emit_signal(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
- r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+ if (unlikely(p_argcount < 1)) {
+ r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+ r_error.expected = 1;
+ ERR_FAIL_V(Error::ERR_INVALID_PARAMETER);
+ }
- ERR_FAIL_COND_V(p_argcount < 1, Error::ERR_INVALID_PARAMETER);
- if (p_args[0]->get_type() != Variant::STRING_NAME && p_args[0]->get_type() != Variant::STRING) {
+ if (unlikely(p_args[0]->get_type() != Variant::STRING_NAME && p_args[0]->get_type() != Variant::STRING)) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 0;
r_error.expected = Variant::STRING_NAME;
- ERR_FAIL_COND_V(p_args[0]->get_type() != Variant::STRING_NAME && p_args[0]->get_type() != Variant::STRING, Error::ERR_INVALID_PARAMETER);
+ ERR_FAIL_V(Error::ERR_INVALID_PARAMETER);
}
r_error.error = Callable::CallError::CALL_OK;
@@ -1791,14 +1805,17 @@ StringName Object::get_class_name_for_extension(const GDExtension *p_library) co
}
void Object::set_instance_binding(void *p_token, void *p_binding, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
- // This is only meant to be used on creation by the binder.
- ERR_FAIL_COND(_instance_bindings != nullptr);
- _instance_bindings = (InstanceBinding *)memalloc(sizeof(InstanceBinding));
+ // This is only meant to be used on creation by the binder, but we also
+ // need to account for reloading (where the 'binding' will be cleared).
+ ERR_FAIL_COND(_instance_bindings != nullptr && _instance_bindings[0].binding != nullptr);
+ if (_instance_bindings == nullptr) {
+ _instance_bindings = (InstanceBinding *)memalloc(sizeof(InstanceBinding));
+ _instance_binding_count = 1;
+ }
_instance_bindings[0].binding = p_binding;
_instance_bindings[0].free_callback = p_callbacks->free_callback;
_instance_bindings[0].reference_callback = p_callbacks->reference_callback;
_instance_bindings[0].token = p_token;
- _instance_binding_count = 1;
}
void *Object::get_instance_binding(void *p_token, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
@@ -1825,6 +1842,12 @@ void *Object::get_instance_binding(void *p_token, const GDExtensionInstanceBindi
binding = p_callbacks->create_callback(p_token, this);
_instance_bindings[_instance_binding_count].binding = binding;
+#ifdef TOOLS_ENABLED
+ if (!_extension && Engine::get_singleton()->is_extension_reloading_enabled()) {
+ GDExtensionManager::get_singleton()->track_instance_binding(p_token, this);
+ }
+#endif
+
_instance_binding_count++;
}
@@ -1848,6 +1871,71 @@ bool Object::has_instance_binding(void *p_token) {
return found;
}
+void Object::free_instance_binding(void *p_token) {
+ bool found = false;
+ _instance_binding_mutex.lock();
+ for (uint32_t i = 0; i < _instance_binding_count; i++) {
+ if (!found && _instance_bindings[i].token == p_token) {
+ if (_instance_bindings[i].free_callback) {
+ _instance_bindings[i].free_callback(_instance_bindings[i].token, this, _instance_bindings[i].binding);
+ }
+ found = true;
+ }
+ if (found) {
+ if (i + 1 < _instance_binding_count) {
+ _instance_bindings[i] = _instance_bindings[i + 1];
+ } else {
+ _instance_bindings[i] = { nullptr };
+ }
+ }
+ }
+ if (found) {
+ _instance_binding_count--;
+ }
+ _instance_binding_mutex.unlock();
+}
+
+#ifdef TOOLS_ENABLED
+void Object::clear_internal_extension() {
+ ERR_FAIL_NULL(_extension);
+
+ // Free the instance inside the GDExtension.
+ if (_extension->free_instance) {
+ _extension->free_instance(_extension->class_userdata, _extension_instance);
+ }
+ _extension = nullptr;
+ _extension_instance = nullptr;
+
+ // Clear the instance bindings.
+ _instance_binding_mutex.lock();
+ if (_instance_bindings[0].free_callback) {
+ _instance_bindings[0].free_callback(_instance_bindings[0].token, this, _instance_bindings[0].binding);
+ }
+ _instance_bindings[0].binding = nullptr;
+ _instance_bindings[0].token = nullptr;
+ _instance_bindings[0].free_callback = nullptr;
+ _instance_bindings[0].reference_callback = nullptr;
+ _instance_binding_mutex.unlock();
+
+ // Clear the virtual methods.
+ while (virtual_method_list) {
+ (*virtual_method_list->method) = nullptr;
+ (*virtual_method_list->initialized) = false;
+ virtual_method_list = virtual_method_list->next;
+ }
+}
+
+void Object::reset_internal_extension(ObjectGDExtension *p_extension) {
+ ERR_FAIL_COND(_extension != nullptr);
+
+ if (p_extension) {
+ _extension_instance = p_extension->recreate_instance ? p_extension->recreate_instance(p_extension->class_userdata, (GDExtensionObjectPtr)this) : nullptr;
+ ERR_FAIL_NULL_MSG(_extension_instance, "Unable to recreate GDExtension instance - does this extension support hot reloading?");
+ _extension = p_extension;
+ }
+}
+#endif
+
void Object::_construct_object(bool p_reference) {
type_is_reference = p_reference;
_instance_id = ObjectDB::add_instance(this);
@@ -1878,11 +1966,25 @@ Object::~Object() {
}
script_instance = nullptr;
- if (_extension && _extension->free_instance) {
- _extension->free_instance(_extension->class_userdata, _extension_instance);
+ if (_extension) {
+#ifdef TOOLS_ENABLED
+ if (_extension->untrack_instance) {
+ _extension->untrack_instance(_extension->tracking_userdata, this);
+ }
+#endif
+ if (_extension->free_instance) {
+ _extension->free_instance(_extension->class_userdata, _extension_instance);
+ }
_extension = nullptr;
_extension_instance = nullptr;
}
+#ifdef TOOLS_ENABLED
+ else if (_instance_bindings != nullptr && Engine::get_singleton()->is_extension_reloading_enabled()) {
+ for (uint32_t i = 0; i < _instance_binding_count; i++) {
+ GDExtensionManager::get_singleton()->untrack_instance_binding(_instance_bindings[i].token, this);
+ }
+ }
+#endif
if (_emitting) {
//@todo this may need to actually reach the debugger prioritarily somehow because it may crash before