From 127458ed175c5aeac8dee7f09d23fae4c8928eb7 Mon Sep 17 00:00:00 2001
From: reduz <reduzio@gmail.com>
Date: Sat, 7 Nov 2020 19:33:38 -0300
Subject: Reorganized core/ directory, it was too fatty already

-Removed FuncRef, since Callable makes it obsolete
-Removed int_types.h as its obsolete in c++11+
-Changed color names code
---
 core/object/object.cpp | 1983 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1983 insertions(+)
 create mode 100644 core/object/object.cpp

(limited to 'core/object/object.cpp')

diff --git a/core/object/object.cpp b/core/object/object.cpp
new file mode 100644
index 0000000000..ffec2ae867
--- /dev/null
+++ b/core/object/object.cpp
@@ -0,0 +1,1983 @@
+/*************************************************************************/
+/*  object.cpp                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* 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.                */
+/*************************************************************************/
+
+#include "object.h"
+
+#include "core/core_string_names.h"
+#include "core/io/resource.h"
+#include "core/object/class_db.h"
+#include "core/object/message_queue.h"
+#include "core/object/script_language.h"
+#include "core/os/os.h"
+#include "core/string/print_string.h"
+#include "core/string/translation.h"
+
+#ifdef DEBUG_ENABLED
+
+struct _ObjectDebugLock {
+	Object *obj;
+
+	_ObjectDebugLock(Object *p_obj) {
+		obj = p_obj;
+		obj->_lock_index.ref();
+	}
+	~_ObjectDebugLock() {
+		obj->_lock_index.unref();
+	}
+};
+
+#define OBJ_DEBUG_LOCK _ObjectDebugLock _debug_lock(this);
+
+#else
+
+#define OBJ_DEBUG_LOCK
+
+#endif
+
+PropertyInfo::operator Dictionary() const {
+	Dictionary d;
+	d["name"] = name;
+	d["class_name"] = class_name;
+	d["type"] = type;
+	d["hint"] = hint;
+	d["hint_string"] = hint_string;
+	d["usage"] = usage;
+	return d;
+}
+
+PropertyInfo PropertyInfo::from_dict(const Dictionary &p_dict) {
+	PropertyInfo pi;
+
+	if (p_dict.has("type")) {
+		pi.type = Variant::Type(int(p_dict["type"]));
+	}
+
+	if (p_dict.has("name")) {
+		pi.name = p_dict["name"];
+	}
+
+	if (p_dict.has("class_name")) {
+		pi.class_name = p_dict["class_name"];
+	}
+
+	if (p_dict.has("hint")) {
+		pi.hint = PropertyHint(int(p_dict["hint"]));
+	}
+
+	if (p_dict.has("hint_string")) {
+		pi.hint_string = p_dict["hint_string"];
+	}
+
+	if (p_dict.has("usage")) {
+		pi.usage = p_dict["usage"];
+	}
+
+	return pi;
+}
+
+Array convert_property_list(const List<PropertyInfo> *p_list) {
+	Array va;
+	for (const List<PropertyInfo>::Element *E = p_list->front(); E; E = E->next()) {
+		va.push_back(Dictionary(E->get()));
+	}
+
+	return va;
+}
+
+MethodInfo::operator Dictionary() const {
+	Dictionary d;
+	d["name"] = name;
+	d["args"] = convert_property_list(&arguments);
+	Array da;
+	for (int i = 0; i < default_arguments.size(); i++) {
+		da.push_back(default_arguments[i]);
+	}
+	d["default_args"] = da;
+	d["flags"] = flags;
+	d["id"] = id;
+	Dictionary r = return_val;
+	d["return"] = r;
+	return d;
+}
+
+MethodInfo MethodInfo::from_dict(const Dictionary &p_dict) {
+	MethodInfo mi;
+
+	if (p_dict.has("name")) {
+		mi.name = p_dict["name"];
+	}
+	Array args;
+	if (p_dict.has("args")) {
+		args = p_dict["args"];
+	}
+
+	for (int i = 0; i < args.size(); i++) {
+		Dictionary d = args[i];
+		mi.arguments.push_back(PropertyInfo::from_dict(d));
+	}
+	Array defargs;
+	if (p_dict.has("default_args")) {
+		defargs = p_dict["default_args"];
+	}
+	for (int i = 0; i < defargs.size(); i++) {
+		mi.default_arguments.push_back(defargs[i]);
+	}
+
+	if (p_dict.has("return")) {
+		mi.return_val = PropertyInfo::from_dict(p_dict["return"]);
+	}
+
+	if (p_dict.has("flags")) {
+		mi.flags = p_dict["flags"];
+	}
+
+	return mi;
+}
+
+MethodInfo::MethodInfo() :
+		flags(METHOD_FLAG_NORMAL) {}
+
+MethodInfo::MethodInfo(const String &p_name) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+}
+
+MethodInfo::MethodInfo(const String &p_name, const PropertyInfo &p_param1) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+}
+
+MethodInfo::MethodInfo(const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+}
+
+MethodInfo::MethodInfo(const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+}
+
+MethodInfo::MethodInfo(const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+}
+
+MethodInfo::MethodInfo(const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4, const PropertyInfo &p_param5) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+	arguments.push_back(p_param5);
+}
+
+MethodInfo::MethodInfo(Variant::Type ret) :
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name, const PropertyInfo &p_param1) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+	arguments.push_back(p_param1);
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+}
+
+MethodInfo::MethodInfo(Variant::Type ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4, const PropertyInfo &p_param5) :
+		name(p_name),
+		flags(METHOD_FLAG_NORMAL) {
+	return_val.type = ret;
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+	arguments.push_back(p_param5);
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name, const PropertyInfo &p_param1) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+}
+
+MethodInfo::MethodInfo(const PropertyInfo &p_ret, const String &p_name, const PropertyInfo &p_param1, const PropertyInfo &p_param2, const PropertyInfo &p_param3, const PropertyInfo &p_param4, const PropertyInfo &p_param5) :
+		name(p_name),
+		return_val(p_ret),
+		flags(METHOD_FLAG_NORMAL) {
+	arguments.push_back(p_param1);
+	arguments.push_back(p_param2);
+	arguments.push_back(p_param3);
+	arguments.push_back(p_param4);
+	arguments.push_back(p_param5);
+}
+
+Object::Connection::operator Variant() const {
+	Dictionary d;
+	d["signal"] = signal;
+	d["callable"] = callable;
+	d["flags"] = flags;
+	d["binds"] = binds;
+	return d;
+}
+
+bool Object::Connection::operator<(const Connection &p_conn) const {
+	if (signal == p_conn.signal) {
+		return callable < p_conn.callable;
+	} else {
+		return signal < p_conn.signal;
+	}
+}
+
+Object::Connection::Connection(const Variant &p_variant) {
+	Dictionary d = p_variant;
+	if (d.has("signal")) {
+		signal = d["signal"];
+	}
+	if (d.has("callable")) {
+		callable = d["callable"];
+	}
+	if (d.has("flags")) {
+		flags = d["flags"];
+	}
+	if (d.has("binds")) {
+		binds = d["binds"];
+	}
+}
+
+bool Object::_predelete() {
+	_predelete_ok = 1;
+	notification(NOTIFICATION_PREDELETE, true);
+	if (_predelete_ok) {
+		_class_ptr = nullptr; //must restore so destructors can access class ptr correctly
+	}
+	return _predelete_ok;
+}
+
+void Object::_postinitialize() {
+	_class_ptr = _get_class_namev();
+	_initialize_classv();
+	notification(NOTIFICATION_POSTINITIALIZE);
+}
+
+void Object::get_valid_parents_static(List<String> *p_parents) {
+}
+
+void Object::_get_valid_parents_static(List<String> *p_parents) {
+}
+
+void Object::set(const StringName &p_name, const Variant &p_value, bool *r_valid) {
+#ifdef TOOLS_ENABLED
+
+	_edited = true;
+#endif
+
+	if (script_instance) {
+		if (script_instance->set(p_name, p_value)) {
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return;
+		}
+	}
+
+	//try built-in setgetter
+	{
+		if (ClassDB::set_property(this, p_name, p_value, r_valid)) {
+			/*
+			if (r_valid)
+				*r_valid=true;
+			*/
+			return;
+		}
+	}
+
+	if (p_name == CoreStringNames::get_singleton()->_script) {
+		set_script(p_value);
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return;
+
+	} else if (p_name == CoreStringNames::get_singleton()->_meta) {
+		//set_meta(p_name,p_value);
+		metadata = p_value.duplicate();
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return;
+	}
+
+	//something inside the object... :|
+	bool success = _setv(p_name, p_value);
+	if (success) {
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return;
+	}
+
+#ifdef TOOLS_ENABLED
+	if (script_instance) {
+		bool valid;
+		script_instance->property_set_fallback(p_name, p_value, &valid);
+		if (valid) {
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return;
+		}
+	}
+#endif
+
+	if (r_valid) {
+		*r_valid = false;
+	}
+}
+
+Variant Object::get(const StringName &p_name, bool *r_valid) const {
+	Variant ret;
+
+	if (script_instance) {
+		if (script_instance->get(p_name, ret)) {
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return ret;
+		}
+	}
+
+	//try built-in setgetter
+	{
+		if (ClassDB::get_property(const_cast<Object *>(this), p_name, ret)) {
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return ret;
+		}
+	}
+
+	if (p_name == CoreStringNames::get_singleton()->_script) {
+		ret = get_script();
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return ret;
+
+	} else if (p_name == CoreStringNames::get_singleton()->_meta) {
+		ret = metadata;
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return ret;
+
+	} else {
+		//something inside the object... :|
+		bool success = _getv(p_name, ret);
+		if (success) {
+			if (r_valid) {
+				*r_valid = true;
+			}
+			return ret;
+		}
+
+#ifdef TOOLS_ENABLED
+		if (script_instance) {
+			bool valid;
+			ret = script_instance->property_get_fallback(p_name, &valid);
+			if (valid) {
+				if (r_valid) {
+					*r_valid = true;
+				}
+				return ret;
+			}
+		}
+#endif
+
+		if (r_valid) {
+			*r_valid = false;
+		}
+		return Variant();
+	}
+}
+
+void Object::set_indexed(const Vector<StringName> &p_names, const Variant &p_value, bool *r_valid) {
+	if (p_names.empty()) {
+		if (r_valid) {
+			*r_valid = false;
+		}
+		return;
+	}
+	if (p_names.size() == 1) {
+		set(p_names[0], p_value, r_valid);
+		return;
+	}
+
+	bool valid = false;
+	if (!r_valid) {
+		r_valid = &valid;
+	}
+
+	List<Variant> value_stack;
+
+	value_stack.push_back(get(p_names[0], r_valid));
+
+	if (!*r_valid) {
+		value_stack.clear();
+		return;
+	}
+
+	for (int i = 1; i < p_names.size() - 1; i++) {
+		value_stack.push_back(value_stack.back()->get().get_named(p_names[i], valid));
+		if (r_valid) {
+			*r_valid = valid;
+		}
+
+		if (!valid) {
+			value_stack.clear();
+			return;
+		}
+	}
+
+	value_stack.push_back(p_value); // p_names[p_names.size() - 1]
+
+	for (int i = p_names.size() - 1; i > 0; i--) {
+		value_stack.back()->prev()->get().set_named(p_names[i], value_stack.back()->get(), valid);
+		value_stack.pop_back();
+
+		if (r_valid) {
+			*r_valid = valid;
+		}
+		if (!valid) {
+			value_stack.clear();
+			return;
+		}
+	}
+
+	set(p_names[0], value_stack.back()->get(), r_valid);
+	value_stack.pop_back();
+
+	ERR_FAIL_COND(!value_stack.empty());
+}
+
+Variant Object::get_indexed(const Vector<StringName> &p_names, bool *r_valid) const {
+	if (p_names.empty()) {
+		if (r_valid) {
+			*r_valid = false;
+		}
+		return Variant();
+	}
+	bool valid = false;
+
+	Variant current_value = get(p_names[0], &valid);
+	for (int i = 1; i < p_names.size(); i++) {
+		current_value = current_value.get_named(p_names[i], valid);
+
+		if (!valid) {
+			break;
+		}
+	}
+	if (r_valid) {
+		*r_valid = valid;
+	}
+
+	return current_value;
+}
+
+void Object::get_property_list(List<PropertyInfo> *p_list, bool p_reversed) const {
+	if (script_instance && p_reversed) {
+		p_list->push_back(PropertyInfo(Variant::NIL, "Script Variables", PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_CATEGORY));
+		script_instance->get_property_list(p_list);
+	}
+
+	_get_property_listv(p_list, p_reversed);
+
+	if (!is_class("Script")) { // can still be set, but this is for userfriendlyness
+#ifdef TOOLS_ENABLED
+		p_list->push_back(PropertyInfo(Variant::NIL, "Script", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_GROUP));
+#endif
+		p_list->push_back(PropertyInfo(Variant::OBJECT, "script", PROPERTY_HINT_RESOURCE_TYPE, "Script", PROPERTY_USAGE_DEFAULT));
+	}
+	if (!metadata.empty()) {
+		p_list->push_back(PropertyInfo(Variant::DICTIONARY, "__meta__", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
+	}
+	if (script_instance && !p_reversed) {
+		p_list->push_back(PropertyInfo(Variant::NIL, "Script Variables", PROPERTY_HINT_NONE, String(), PROPERTY_USAGE_CATEGORY));
+		script_instance->get_property_list(p_list);
+	}
+}
+
+void Object::_validate_property(PropertyInfo &property) const {
+}
+
+void Object::get_method_list(List<MethodInfo> *p_list) const {
+	ClassDB::get_method_list(get_class_name(), p_list);
+	if (script_instance) {
+		script_instance->get_method_list(p_list);
+	}
+}
+
+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;
+		return Variant();
+	}
+
+	if (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;
+		return Variant();
+	}
+
+	StringName method = *p_args[0];
+
+	return call(method, &p_args[1], p_argcount - 1, r_error);
+}
+
+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;
+		return Variant();
+	}
+
+	if (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;
+		return Variant();
+	}
+
+	r_error.error = Callable::CallError::CALL_OK;
+
+	StringName method = *p_args[0];
+
+	MessageQueue::get_singleton()->push_call(get_instance_id(), method, &p_args[1], p_argcount - 1, true);
+
+	return Variant();
+}
+
+bool Object::has_method(const StringName &p_method) const {
+	if (p_method == CoreStringNames::get_singleton()->_free) {
+		return true;
+	}
+
+	if (script_instance && script_instance->has_method(p_method)) {
+		return true;
+	}
+
+	MethodBind *method = ClassDB::get_method(get_class_name(), p_method);
+
+	return method != nullptr;
+}
+
+Variant Object::getvar(const Variant &p_key, bool *r_valid) const {
+	if (r_valid) {
+		*r_valid = false;
+	}
+
+	if (p_key.get_type() == Variant::STRING_NAME || p_key.get_type() == Variant::STRING) {
+		return get(p_key, r_valid);
+	}
+	return Variant();
+}
+
+void Object::setvar(const Variant &p_key, const Variant &p_value, bool *r_valid) {
+	if (r_valid) {
+		*r_valid = false;
+	}
+	if (p_key.get_type() == Variant::STRING_NAME || p_key.get_type() == Variant::STRING) {
+		return set(p_key, p_value, r_valid);
+	}
+}
+
+Variant Object::callv(const StringName &p_method, const Array &p_args) {
+	const Variant **argptrs = nullptr;
+
+	if (p_args.size() > 0) {
+		argptrs = (const Variant **)alloca(sizeof(Variant *) * p_args.size());
+		for (int i = 0; i < p_args.size(); i++) {
+			argptrs[i] = &p_args[i];
+		}
+	}
+
+	Callable::CallError ce;
+	Variant ret = call(p_method, argptrs, p_args.size(), ce);
+	if (ce.error != Callable::CallError::CALL_OK) {
+		ERR_FAIL_V_MSG(Variant(), "Error calling method from 'callv': " + Variant::get_call_error_text(this, p_method, argptrs, p_args.size(), ce) + ".");
+	}
+	return ret;
+}
+
+Variant Object::call(const StringName &p_name, VARIANT_ARG_DECLARE) {
+	VARIANT_ARGPTRS;
+
+	int argc = 0;
+	for (int i = 0; i < VARIANT_ARG_MAX; i++) {
+		if (argptr[i]->get_type() == Variant::NIL) {
+			break;
+		}
+		argc++;
+	}
+
+	Callable::CallError error;
+
+	Variant ret = call(p_name, argptr, argc, error);
+	return ret;
+}
+
+Variant Object::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	r_error.error = Callable::CallError::CALL_OK;
+
+	if (p_method == CoreStringNames::get_singleton()->_free) {
+//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;
+			return Variant();
+		}
+		if (Object::cast_to<Reference>(this)) {
+			r_error.argument = 0;
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+			ERR_FAIL_V_MSG(Variant(), "Can't 'free' a reference.");
+		}
+
+		if (_lock_index.get() > 1) {
+			r_error.argument = 0;
+			r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+			ERR_FAIL_V_MSG(Variant(), "Object is locked and can't be freed.");
+		}
+
+#endif
+		//must be here, must be before everything,
+		memdelete(this);
+		r_error.error = Callable::CallError::CALL_OK;
+		return Variant();
+	}
+
+	Variant ret;
+	OBJ_DEBUG_LOCK
+	if (script_instance) {
+		ret = script_instance->call(p_method, p_args, p_argcount, r_error);
+		//force jumptable
+		switch (r_error.error) {
+			case Callable::CallError::CALL_OK:
+				return ret;
+			case Callable::CallError::CALL_ERROR_INVALID_METHOD:
+				break;
+			case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
+			case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
+			case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
+				return ret;
+			case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL: {
+			}
+		}
+	}
+
+	MethodBind *method = ClassDB::get_method(get_class_name(), p_method);
+
+	if (method) {
+		ret = method->call(this, p_args, p_argcount, r_error);
+	} else {
+		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+	}
+
+	return ret;
+}
+
+void Object::notification(int p_notification, bool p_reversed) {
+	_notificationv(p_notification, p_reversed);
+
+	if (script_instance) {
+		script_instance->notification(p_notification);
+	}
+}
+
+String Object::to_string() {
+	if (script_instance) {
+		bool valid;
+		String ret = script_instance->to_string(&valid);
+		if (valid) {
+			return ret;
+		}
+	}
+	return "[" + get_class() + ":" + itos(get_instance_id()) + "]";
+}
+
+void Object::_changed_callback(Object *p_changed, const char *p_prop) {
+}
+
+void Object::add_change_receptor(Object *p_receptor) {
+	change_receptors.insert(p_receptor);
+}
+
+void Object::remove_change_receptor(Object *p_receptor) {
+	change_receptors.erase(p_receptor);
+}
+
+void Object::property_list_changed_notify() {
+	_change_notify();
+}
+
+void Object::cancel_delete() {
+	_predelete_ok = true;
+}
+
+void Object::set_script_and_instance(const Variant &p_script, ScriptInstance *p_instance) {
+	//this function is not meant to be used in any of these ways
+	ERR_FAIL_COND(p_script.is_null());
+	ERR_FAIL_COND(!p_instance);
+	ERR_FAIL_COND(script_instance != nullptr || !script.is_null());
+
+	script = p_script;
+	script_instance = p_instance;
+}
+
+void Object::set_script(const Variant &p_script) {
+	if (script == p_script) {
+		return;
+	}
+
+	if (script_instance) {
+		memdelete(script_instance);
+		script_instance = nullptr;
+	}
+
+	script = p_script;
+	Ref<Script> s = script;
+
+	if (!s.is_null()) {
+		if (s->can_instance()) {
+			OBJ_DEBUG_LOCK
+			script_instance = s->instance_create(this);
+		} else if (Engine::get_singleton()->is_editor_hint()) {
+			OBJ_DEBUG_LOCK
+			script_instance = s->placeholder_instance_create(this);
+		}
+	}
+
+	_change_notify(); //scripts may add variables, so refresh is desired
+	emit_signal(CoreStringNames::get_singleton()->script_changed);
+}
+
+void Object::set_script_instance(ScriptInstance *p_instance) {
+	if (script_instance == p_instance) {
+		return;
+	}
+
+	if (script_instance) {
+		memdelete(script_instance);
+	}
+
+	script_instance = p_instance;
+
+	if (p_instance) {
+		script = p_instance->get_script();
+	} else {
+		script = Variant();
+	}
+}
+
+Variant Object::get_script() const {
+	return script;
+}
+
+bool Object::has_meta(const String &p_name) const {
+	return metadata.has(p_name);
+}
+
+void Object::set_meta(const String &p_name, const Variant &p_value) {
+	if (p_value.get_type() == Variant::NIL) {
+		metadata.erase(p_name);
+		return;
+	}
+
+	metadata[p_name] = p_value;
+}
+
+Variant Object::get_meta(const String &p_name) const {
+	ERR_FAIL_COND_V(!metadata.has(p_name), Variant());
+	return metadata[p_name];
+}
+
+void Object::remove_meta(const String &p_name) {
+	metadata.erase(p_name);
+}
+
+Array Object::_get_property_list_bind() const {
+	List<PropertyInfo> lpi;
+	get_property_list(&lpi);
+	return convert_property_list(&lpi);
+}
+
+Array Object::_get_method_list_bind() const {
+	List<MethodInfo> ml;
+	get_method_list(&ml);
+	Array ret;
+
+	for (List<MethodInfo>::Element *E = ml.front(); E; E = E->next()) {
+		Dictionary d = E->get();
+		//va.push_back(d);
+		ret.push_back(d);
+	}
+
+	return ret;
+}
+
+Vector<String> Object::_get_meta_list_bind() const {
+	Vector<String> _metaret;
+
+	List<Variant> keys;
+	metadata.get_key_list(&keys);
+	for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+		_metaret.push_back(E->get());
+	}
+
+	return _metaret;
+}
+
+void Object::get_meta_list(List<String> *p_list) const {
+	List<Variant> keys;
+	metadata.get_key_list(&keys);
+	for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+		p_list->push_back(E->get());
+	}
+}
+
+void Object::add_user_signal(const MethodInfo &p_signal) {
+	ERR_FAIL_COND_MSG(p_signal.name == "", "Signal name cannot be empty.");
+	ERR_FAIL_COND_MSG(ClassDB::has_signal(get_class_name(), p_signal.name), "User signal's name conflicts with a built-in signal of '" + get_class_name() + "'.");
+	ERR_FAIL_COND_MSG(signal_map.has(p_signal.name), "Trying to add already existing signal '" + p_signal.name + "'.");
+	SignalData s;
+	s.user = p_signal;
+	signal_map[p_signal.name] = s;
+}
+
+bool Object::_has_user_signal(const StringName &p_name) const {
+	if (!signal_map.has(p_name)) {
+		return false;
+	}
+	return signal_map[p_name].user.name.length() > 0;
+}
+
+struct _ObjectSignalDisconnectData {
+	StringName signal;
+	Callable callable;
+};
+
+Variant Object::_emit_signal(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
+
+	ERR_FAIL_COND_V(p_argcount < 1, Variant());
+	if (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, Variant());
+	}
+
+	r_error.error = Callable::CallError::CALL_OK;
+
+	StringName signal = *p_args[0];
+
+	const Variant **args = nullptr;
+
+	int argc = p_argcount - 1;
+	if (argc) {
+		args = &p_args[1];
+	}
+
+	emit_signal(signal, args, argc);
+
+	return Variant();
+}
+
+Error Object::emit_signal(const StringName &p_name, const Variant **p_args, int p_argcount) {
+	if (_block_signals) {
+		return ERR_CANT_ACQUIRE_RESOURCE; //no emit, signals blocked
+	}
+
+	SignalData *s = signal_map.getptr(p_name);
+	if (!s) {
+#ifdef DEBUG_ENABLED
+		bool signal_is_valid = ClassDB::has_signal(get_class_name(), p_name);
+		//check in script
+		ERR_FAIL_COND_V_MSG(!signal_is_valid && !script.is_null() && !Ref<Script>(script)->has_script_signal(p_name), ERR_UNAVAILABLE, "Can't emit non-existing signal " + String("\"") + p_name + "\".");
+#endif
+		//not connected? just return
+		return ERR_UNAVAILABLE;
+	}
+
+	List<_ObjectSignalDisconnectData> disconnect_data;
+
+	//copy on write will ensure that disconnecting the signal or even deleting the object will not affect the signal calling.
+	//this happens automatically and will not change the performance of calling.
+	//awesome, isn't it?
+	VMap<Callable, SignalData::Slot> slot_map = s->slot_map;
+
+	int ssize = slot_map.size();
+
+	OBJ_DEBUG_LOCK
+
+	Vector<const Variant *> bind_mem;
+
+	Error err = OK;
+
+	for (int i = 0; i < ssize; i++) {
+		const Connection &c = slot_map.getv(i).conn;
+
+		Object *target = c.callable.get_object();
+		if (!target) {
+			// Target might have been deleted during signal callback, this is expected and OK.
+			continue;
+		}
+
+		const Variant **args = p_args;
+		int argc = p_argcount;
+
+		if (c.binds.size()) {
+			//handle binds
+			bind_mem.resize(p_argcount + c.binds.size());
+
+			for (int j = 0; j < p_argcount; j++) {
+				bind_mem.write[j] = p_args[j];
+			}
+			for (int j = 0; j < c.binds.size(); j++) {
+				bind_mem.write[p_argcount + j] = &c.binds[j];
+			}
+
+			args = (const Variant **)bind_mem.ptr();
+			argc = bind_mem.size();
+		}
+
+		if (c.flags & CONNECT_DEFERRED) {
+			MessageQueue::get_singleton()->push_callable(c.callable, args, argc, true);
+		} else {
+			Callable::CallError ce;
+			_emitting = true;
+			Variant ret;
+			c.callable.call(args, argc, ret, ce);
+			_emitting = false;
+
+			if (ce.error != Callable::CallError::CALL_OK) {
+#ifdef DEBUG_ENABLED
+				if (c.flags & CONNECT_PERSIST && Engine::get_singleton()->is_editor_hint() && (script.is_null() || !Ref<Script>(script)->is_tool())) {
+					continue;
+				}
+#endif
+				if (ce.error == Callable::CallError::CALL_ERROR_INVALID_METHOD && !ClassDB::class_exists(target->get_class_name())) {
+					//most likely object is not initialized yet, do not throw error.
+				} else {
+					ERR_PRINT("Error calling from signal '" + String(p_name) + "' to callable: " + Variant::get_callable_error_text(c.callable, args, argc, ce) + ".");
+					err = ERR_METHOD_NOT_FOUND;
+				}
+			}
+		}
+
+		bool disconnect = c.flags & CONNECT_ONESHOT;
+#ifdef TOOLS_ENABLED
+		if (disconnect && (c.flags & CONNECT_PERSIST) && Engine::get_singleton()->is_editor_hint()) {
+			//this signal was connected from the editor, and is being edited. just don't disconnect for now
+			disconnect = false;
+		}
+#endif
+		if (disconnect) {
+			_ObjectSignalDisconnectData dd;
+			dd.signal = p_name;
+			dd.callable = c.callable;
+			disconnect_data.push_back(dd);
+		}
+	}
+
+	while (!disconnect_data.empty()) {
+		const _ObjectSignalDisconnectData &dd = disconnect_data.front()->get();
+
+		_disconnect(dd.signal, dd.callable);
+		disconnect_data.pop_front();
+	}
+
+	return err;
+}
+
+Error Object::emit_signal(const StringName &p_name, VARIANT_ARG_DECLARE) {
+	VARIANT_ARGPTRS;
+
+	int argc = 0;
+
+	for (int i = 0; i < VARIANT_ARG_MAX; i++) {
+		if (argptr[i]->get_type() == Variant::NIL) {
+			break;
+		}
+		argc++;
+	}
+
+	return emit_signal(p_name, argptr, argc);
+}
+
+void Object::_add_user_signal(const String &p_name, const Array &p_args) {
+	// this version of add_user_signal is meant to be used from scripts or external apis
+	// without access to ADD_SIGNAL in bind_methods
+	// added events are per instance, as opposed to the other ones, which are global
+
+	MethodInfo mi;
+	mi.name = p_name;
+
+	for (int i = 0; i < p_args.size(); i++) {
+		Dictionary d = p_args[i];
+		PropertyInfo param;
+
+		if (d.has("name")) {
+			param.name = d["name"];
+		}
+		if (d.has("type")) {
+			param.type = (Variant::Type)(int)d["type"];
+		}
+
+		mi.arguments.push_back(param);
+	}
+
+	add_user_signal(mi);
+}
+
+Array Object::_get_signal_list() const {
+	List<MethodInfo> signal_list;
+	get_signal_list(&signal_list);
+
+	Array ret;
+	for (List<MethodInfo>::Element *E = signal_list.front(); E; E = E->next()) {
+		ret.push_back(Dictionary(E->get()));
+	}
+
+	return ret;
+}
+
+Array Object::_get_signal_connection_list(const String &p_signal) const {
+	List<Connection> conns;
+	get_all_signal_connections(&conns);
+
+	Array ret;
+
+	for (List<Connection>::Element *E = conns.front(); E; E = E->next()) {
+		Connection &c = E->get();
+		if (c.signal.get_name() == p_signal) {
+			ret.push_back(c);
+		}
+	}
+
+	return ret;
+}
+
+Array Object::_get_incoming_connections() const {
+	Array ret;
+	int connections_amount = connections.size();
+	for (int idx_conn = 0; idx_conn < connections_amount; idx_conn++) {
+		ret.push_back(connections[idx_conn]);
+	}
+
+	return ret;
+}
+
+bool Object::has_signal(const StringName &p_name) const {
+	if (!script.is_null()) {
+		Ref<Script> scr = script;
+		if (scr.is_valid() && scr->has_script_signal(p_name)) {
+			return true;
+		}
+	}
+
+	if (ClassDB::has_signal(get_class_name(), p_name)) {
+		return true;
+	}
+
+	if (_has_user_signal(p_name)) {
+		return true;
+	}
+
+	return false;
+}
+
+void Object::get_signal_list(List<MethodInfo> *p_signals) const {
+	if (!script.is_null()) {
+		Ref<Script> scr = script;
+		if (scr.is_valid()) {
+			scr->get_script_signal_list(p_signals);
+		}
+	}
+
+	ClassDB::get_signal_list(get_class_name(), p_signals);
+	//find maybe usersignals?
+	const StringName *S = nullptr;
+
+	while ((S = signal_map.next(S))) {
+		if (signal_map[*S].user.name != "") {
+			//user signal
+			p_signals->push_back(signal_map[*S].user);
+		}
+	}
+}
+
+void Object::get_all_signal_connections(List<Connection> *p_connections) const {
+	const StringName *S = nullptr;
+
+	while ((S = signal_map.next(S))) {
+		const SignalData *s = &signal_map[*S];
+
+		for (int i = 0; i < s->slot_map.size(); i++) {
+			p_connections->push_back(s->slot_map.getv(i).conn);
+		}
+	}
+}
+
+void Object::get_signal_connection_list(const StringName &p_signal, List<Connection> *p_connections) const {
+	const SignalData *s = signal_map.getptr(p_signal);
+	if (!s) {
+		return; //nothing
+	}
+
+	for (int i = 0; i < s->slot_map.size(); i++) {
+		p_connections->push_back(s->slot_map.getv(i).conn);
+	}
+}
+
+int Object::get_persistent_signal_connection_count() const {
+	int count = 0;
+	const StringName *S = nullptr;
+
+	while ((S = signal_map.next(S))) {
+		const SignalData *s = &signal_map[*S];
+
+		for (int i = 0; i < s->slot_map.size(); i++) {
+			if (s->slot_map.getv(i).conn.flags & CONNECT_PERSIST) {
+				count += 1;
+			}
+		}
+	}
+
+	return count;
+}
+
+void Object::get_signals_connected_to_this(List<Connection> *p_connections) const {
+	for (const List<Connection>::Element *E = connections.front(); E; E = E->next()) {
+		p_connections->push_back(E->get());
+	}
+}
+
+Error Object::connect_compat(const StringName &p_signal, Object *p_to_object, const StringName &p_to_method, const Vector<Variant> &p_binds, uint32_t p_flags) {
+	return connect(p_signal, Callable(p_to_object, p_to_method), p_binds, p_flags);
+}
+
+Error Object::connect(const StringName &p_signal, const Callable &p_callable, const Vector<Variant> &p_binds, uint32_t p_flags) {
+	ERR_FAIL_COND_V(p_callable.is_null(), ERR_INVALID_PARAMETER);
+
+	Object *target_object = p_callable.get_object();
+	ERR_FAIL_COND_V(!target_object, ERR_INVALID_PARAMETER);
+
+	SignalData *s = signal_map.getptr(p_signal);
+	if (!s) {
+		bool signal_is_valid = ClassDB::has_signal(get_class_name(), p_signal);
+		//check in script
+		if (!signal_is_valid && !script.is_null()) {
+			if (Ref<Script>(script)->has_script_signal(p_signal)) {
+				signal_is_valid = true;
+			}
+#ifdef TOOLS_ENABLED
+			else {
+				//allow connecting signals anyway if script is invalid, see issue #17070
+				if (!Ref<Script>(script)->is_valid()) {
+					signal_is_valid = true;
+				}
+			}
+#endif
+		}
+
+		ERR_FAIL_COND_V_MSG(!signal_is_valid, ERR_INVALID_PARAMETER, "In Object of type '" + String(get_class()) + "': Attempt to connect nonexistent signal '" + p_signal + "' to callable '" + p_callable + "'.");
+
+		signal_map[p_signal] = SignalData();
+		s = &signal_map[p_signal];
+	}
+
+	Callable target = p_callable;
+
+	//compare with the base callable, so binds can be ignored
+	if (s->slot_map.has(*target.get_base_comparator())) {
+		if (p_flags & CONNECT_REFERENCE_COUNTED) {
+			s->slot_map[*target.get_base_comparator()].reference_count++;
+			return OK;
+		} else {
+			ERR_FAIL_V_MSG(ERR_INVALID_PARAMETER, "Signal '" + p_signal + "' is already connected to given callable '" + p_callable + "' in that object.");
+		}
+	}
+
+	SignalData::Slot slot;
+
+	Connection conn;
+	conn.callable = target;
+	conn.signal = ::Signal(this, p_signal);
+	conn.flags = p_flags;
+	conn.binds = p_binds;
+	slot.conn = conn;
+	slot.cE = target_object->connections.push_back(conn);
+	if (p_flags & CONNECT_REFERENCE_COUNTED) {
+		slot.reference_count = 1;
+	}
+
+	//use callable version as key, so binds can be ignored
+	s->slot_map[*target.get_base_comparator()] = slot;
+
+	return OK;
+}
+
+bool Object::is_connected_compat(const StringName &p_signal, Object *p_to_object, const StringName &p_to_method) const {
+	return is_connected(p_signal, Callable(p_to_object, p_to_method));
+}
+
+bool Object::is_connected(const StringName &p_signal, const Callable &p_callable) const {
+	ERR_FAIL_COND_V(p_callable.is_null(), false);
+	const SignalData *s = signal_map.getptr(p_signal);
+	if (!s) {
+		bool signal_is_valid = ClassDB::has_signal(get_class_name(), p_signal);
+		if (signal_is_valid) {
+			return false;
+		}
+
+		if (!script.is_null() && Ref<Script>(script)->has_script_signal(p_signal)) {
+			return false;
+		}
+
+		ERR_FAIL_V_MSG(false, "Nonexistent signal: " + p_signal + ".");
+	}
+
+	Callable target = p_callable;
+
+	return s->slot_map.has(*target.get_base_comparator());
+	//const Map<Signal::Target,Signal::Slot>::Element *E = s->slot_map.find(target);
+	//return (E!=nullptr );
+}
+
+void Object::disconnect_compat(const StringName &p_signal, Object *p_to_object, const StringName &p_to_method) {
+	_disconnect(p_signal, Callable(p_to_object, p_to_method));
+}
+
+void Object::disconnect(const StringName &p_signal, const Callable &p_callable) {
+	_disconnect(p_signal, p_callable);
+}
+
+void Object::_disconnect(const StringName &p_signal, const Callable &p_callable, bool p_force) {
+	ERR_FAIL_COND(p_callable.is_null());
+
+	Object *target_object = p_callable.get_object();
+	ERR_FAIL_COND(!target_object);
+
+	SignalData *s = signal_map.getptr(p_signal);
+	ERR_FAIL_COND_MSG(!s, vformat("Nonexistent signal '%s' in %s.", p_signal, to_string()));
+
+	ERR_FAIL_COND_MSG(!s->slot_map.has(*p_callable.get_base_comparator()), "Disconnecting nonexistent signal '" + p_signal + "', callable: " + p_callable + ".");
+
+	SignalData::Slot *slot = &s->slot_map[p_callable];
+
+	if (!p_force) {
+		slot->reference_count--; // by default is zero, if it was not referenced it will go below it
+		if (slot->reference_count >= 0) {
+			return;
+		}
+	}
+
+	target_object->connections.erase(slot->cE);
+	s->slot_map.erase(*p_callable.get_base_comparator());
+
+	if (s->slot_map.empty() && ClassDB::has_signal(get_class_name(), p_signal)) {
+		//not user signal, delete
+		signal_map.erase(p_signal);
+	}
+}
+
+void Object::_set_bind(const String &p_set, const Variant &p_value) {
+	set(p_set, p_value);
+}
+
+Variant Object::_get_bind(const String &p_name) const {
+	return get(p_name);
+}
+
+void Object::_set_indexed_bind(const NodePath &p_name, const Variant &p_value) {
+	set_indexed(p_name.get_as_property_path().get_subnames(), p_value);
+}
+
+Variant Object::_get_indexed_bind(const NodePath &p_name) const {
+	return get_indexed(p_name.get_as_property_path().get_subnames());
+}
+
+void Object::initialize_class() {
+	static bool initialized = false;
+	if (initialized) {
+		return;
+	}
+	ClassDB::_add_class<Object>();
+	_bind_methods();
+	initialized = true;
+}
+
+String Object::tr(const StringName &p_message, const StringName &p_context) const {
+	if (!_can_translate || !TranslationServer::get_singleton()) {
+		return p_message;
+	}
+	return TranslationServer::get_singleton()->translate(p_message, p_context);
+}
+
+String Object::tr_n(const StringName &p_message, const StringName &p_message_plural, int p_n, const StringName &p_context) const {
+	if (!_can_translate || !TranslationServer::get_singleton()) {
+		// Return message based on English plural rule if translation is not possible.
+		if (p_n == 1) {
+			return p_message;
+		}
+		return p_message_plural;
+	}
+	return TranslationServer::get_singleton()->translate_plural(p_message, p_message_plural, p_n, p_context);
+}
+
+void Object::_clear_internal_resource_paths(const Variant &p_var) {
+	switch (p_var.get_type()) {
+		case Variant::OBJECT: {
+			RES r = p_var;
+			if (!r.is_valid()) {
+				return;
+			}
+
+			if (!r->get_path().begins_with("res://") || r->get_path().find("::") == -1) {
+				return; //not an internal resource
+			}
+
+			Object *object = p_var;
+			if (!object) {
+				return;
+			}
+
+			r->set_path("");
+			r->clear_internal_resource_paths();
+		} break;
+		case Variant::ARRAY: {
+			Array a = p_var;
+			for (int i = 0; i < a.size(); i++) {
+				_clear_internal_resource_paths(a[i]);
+			}
+
+		} break;
+		case Variant::DICTIONARY: {
+			Dictionary d = p_var;
+			List<Variant> keys;
+			d.get_key_list(&keys);
+
+			for (List<Variant>::Element *E = keys.front(); E; E = E->next()) {
+				_clear_internal_resource_paths(E->get());
+				_clear_internal_resource_paths(d[E->get()]);
+			}
+		} break;
+		default: {
+		}
+	}
+}
+
+#ifdef TOOLS_ENABLED
+void Object::editor_set_section_unfold(const String &p_section, bool p_unfolded) {
+	set_edited(true);
+	if (p_unfolded) {
+		editor_section_folding.insert(p_section);
+	} else {
+		editor_section_folding.erase(p_section);
+	}
+}
+
+bool Object::editor_is_section_unfolded(const String &p_section) {
+	return editor_section_folding.has(p_section);
+}
+
+#endif
+
+void Object::clear_internal_resource_paths() {
+	List<PropertyInfo> pinfo;
+
+	get_property_list(&pinfo);
+
+	for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
+		_clear_internal_resource_paths(get(E->get().name));
+	}
+}
+
+void Object::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_class"), &Object::get_class);
+	ClassDB::bind_method(D_METHOD("is_class", "class"), &Object::is_class);
+	ClassDB::bind_method(D_METHOD("set", "property", "value"), &Object::_set_bind);
+	ClassDB::bind_method(D_METHOD("get", "property"), &Object::_get_bind);
+	ClassDB::bind_method(D_METHOD("set_indexed", "property", "value"), &Object::_set_indexed_bind);
+	ClassDB::bind_method(D_METHOD("get_indexed", "property"), &Object::_get_indexed_bind);
+	ClassDB::bind_method(D_METHOD("get_property_list"), &Object::_get_property_list_bind);
+	ClassDB::bind_method(D_METHOD("get_method_list"), &Object::_get_method_list_bind);
+	ClassDB::bind_method(D_METHOD("notification", "what", "reversed"), &Object::notification, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("to_string"), &Object::to_string);
+	ClassDB::bind_method(D_METHOD("get_instance_id"), &Object::get_instance_id);
+
+	ClassDB::bind_method(D_METHOD("set_script", "script"), &Object::set_script);
+	ClassDB::bind_method(D_METHOD("get_script"), &Object::get_script);
+
+	ClassDB::bind_method(D_METHOD("set_meta", "name", "value"), &Object::set_meta);
+	ClassDB::bind_method(D_METHOD("remove_meta", "name"), &Object::remove_meta);
+	ClassDB::bind_method(D_METHOD("get_meta", "name"), &Object::get_meta);
+	ClassDB::bind_method(D_METHOD("has_meta", "name"), &Object::has_meta);
+	ClassDB::bind_method(D_METHOD("get_meta_list"), &Object::_get_meta_list_bind);
+
+	ClassDB::bind_method(D_METHOD("add_user_signal", "signal", "arguments"), &Object::_add_user_signal, DEFVAL(Array()));
+	ClassDB::bind_method(D_METHOD("has_user_signal", "signal"), &Object::_has_user_signal);
+
+	{
+		MethodInfo mi;
+		mi.name = "emit_signal";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING_NAME, "signal"));
+
+		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "emit_signal", &Object::_emit_signal, mi, varray(), false);
+	}
+
+	{
+		MethodInfo mi;
+		mi.name = "call";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING_NAME, "method"));
+
+		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call", &Object::_call_bind, mi);
+	}
+
+	{
+		MethodInfo mi;
+		mi.name = "call_deferred";
+		mi.arguments.push_back(PropertyInfo(Variant::STRING_NAME, "method"));
+
+		ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "call_deferred", &Object::_call_deferred_bind, mi, varray(), false);
+	}
+
+	ClassDB::bind_method(D_METHOD("set_deferred", "property", "value"), &Object::set_deferred);
+
+	ClassDB::bind_method(D_METHOD("callv", "method", "arg_array"), &Object::callv);
+
+	ClassDB::bind_method(D_METHOD("has_method", "method"), &Object::has_method);
+
+	ClassDB::bind_method(D_METHOD("has_signal", "signal"), &Object::has_signal);
+	ClassDB::bind_method(D_METHOD("get_signal_list"), &Object::_get_signal_list);
+	ClassDB::bind_method(D_METHOD("get_signal_connection_list", "signal"), &Object::_get_signal_connection_list);
+	ClassDB::bind_method(D_METHOD("get_incoming_connections"), &Object::_get_incoming_connections);
+
+	ClassDB::bind_method(D_METHOD("connect", "signal", "callable", "binds", "flags"), &Object::connect, DEFVAL(Array()), DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("disconnect", "signal", "callable"), &Object::disconnect);
+	ClassDB::bind_method(D_METHOD("is_connected", "signal", "callable"), &Object::is_connected);
+
+	ClassDB::bind_method(D_METHOD("set_block_signals", "enable"), &Object::set_block_signals);
+	ClassDB::bind_method(D_METHOD("is_blocking_signals"), &Object::is_blocking_signals);
+	ClassDB::bind_method(D_METHOD("property_list_changed_notify"), &Object::property_list_changed_notify);
+
+	ClassDB::bind_method(D_METHOD("set_message_translation", "enable"), &Object::set_message_translation);
+	ClassDB::bind_method(D_METHOD("can_translate_messages"), &Object::can_translate_messages);
+	ClassDB::bind_method(D_METHOD("tr", "message", "context"), &Object::tr, DEFVAL(""));
+	ClassDB::bind_method(D_METHOD("tr_n", "message", "plural_message", "n", "context"), &Object::tr_n, DEFVAL(""));
+
+	ClassDB::bind_method(D_METHOD("is_queued_for_deletion"), &Object::is_queued_for_deletion);
+
+	ClassDB::add_virtual_method("Object", MethodInfo("free"), false);
+
+	ADD_SIGNAL(MethodInfo("script_changed"));
+
+	BIND_VMETHOD(MethodInfo("_notification", PropertyInfo(Variant::INT, "what")));
+	BIND_VMETHOD(MethodInfo(Variant::BOOL, "_set", PropertyInfo(Variant::STRING_NAME, "property"), PropertyInfo(Variant::NIL, "value")));
+#ifdef TOOLS_ENABLED
+	MethodInfo miget("_get", PropertyInfo(Variant::STRING_NAME, "property"));
+	miget.return_val.name = "Variant";
+	miget.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
+	BIND_VMETHOD(miget);
+
+	MethodInfo plget("_get_property_list");
+
+	plget.return_val.type = Variant::ARRAY;
+	BIND_VMETHOD(plget);
+
+#endif
+	BIND_VMETHOD(MethodInfo("_init"));
+	BIND_VMETHOD(MethodInfo(Variant::STRING, "_to_string"));
+
+	BIND_CONSTANT(NOTIFICATION_POSTINITIALIZE);
+	BIND_CONSTANT(NOTIFICATION_PREDELETE);
+
+	BIND_ENUM_CONSTANT(CONNECT_DEFERRED);
+	BIND_ENUM_CONSTANT(CONNECT_PERSIST);
+	BIND_ENUM_CONSTANT(CONNECT_ONESHOT);
+	BIND_ENUM_CONSTANT(CONNECT_REFERENCE_COUNTED);
+}
+
+void Object::call_deferred(const StringName &p_method, VARIANT_ARG_DECLARE) {
+	MessageQueue::get_singleton()->push_call(this, p_method, VARIANT_ARG_PASS);
+}
+
+void Object::set_deferred(const StringName &p_property, const Variant &p_value) {
+	MessageQueue::get_singleton()->push_set(this, p_property, p_value);
+}
+
+void Object::set_block_signals(bool p_block) {
+	_block_signals = p_block;
+}
+
+bool Object::is_blocking_signals() const {
+	return _block_signals;
+}
+
+void Object::get_translatable_strings(List<String> *p_strings) const {
+	List<PropertyInfo> plist;
+	get_property_list(&plist);
+
+	for (List<PropertyInfo>::Element *E = plist.front(); E; E = E->next()) {
+		if (!(E->get().usage & PROPERTY_USAGE_INTERNATIONALIZED)) {
+			continue;
+		}
+
+		String text = get(E->get().name);
+
+		if (text == "") {
+			continue;
+		}
+
+		p_strings->push_back(text);
+	}
+}
+
+Variant::Type Object::get_static_property_type(const StringName &p_property, bool *r_valid) const {
+	bool valid;
+	Variant::Type t = ClassDB::get_property_type(get_class_name(), p_property, &valid);
+	if (valid) {
+		if (r_valid) {
+			*r_valid = true;
+		}
+		return t;
+	}
+
+	if (get_script_instance()) {
+		return get_script_instance()->get_property_type(p_property, r_valid);
+	}
+	if (r_valid) {
+		*r_valid = false;
+	}
+
+	return Variant::NIL;
+}
+
+Variant::Type Object::get_static_property_type_indexed(const Vector<StringName> &p_path, bool *r_valid) const {
+	if (p_path.size() == 0) {
+		if (r_valid) {
+			*r_valid = false;
+		}
+
+		return Variant::NIL;
+	}
+
+	bool valid = false;
+	Variant::Type t = get_static_property_type(p_path[0], &valid);
+	if (!valid) {
+		if (r_valid) {
+			*r_valid = false;
+		}
+
+		return Variant::NIL;
+	}
+
+	Callable::CallError ce;
+	Variant check = Variant::construct(t, nullptr, 0, ce);
+
+	for (int i = 1; i < p_path.size(); i++) {
+		if (check.get_type() == Variant::OBJECT || check.get_type() == Variant::DICTIONARY || check.get_type() == Variant::ARRAY) {
+			// We cannot be sure about the type of properties this types can have
+			if (r_valid) {
+				*r_valid = false;
+			}
+			return Variant::NIL;
+		}
+
+		check = check.get_named(p_path[i], valid);
+
+		if (!valid) {
+			if (r_valid) {
+				*r_valid = false;
+			}
+			return Variant::NIL;
+		}
+	}
+
+	if (r_valid) {
+		*r_valid = true;
+	}
+
+	return check.get_type();
+}
+
+bool Object::is_queued_for_deletion() const {
+	return _is_queued_for_deletion;
+}
+
+#ifdef TOOLS_ENABLED
+void Object::set_edited(bool p_edited) {
+	_edited = p_edited;
+	_edited_version++;
+}
+
+bool Object::is_edited() const {
+	return _edited;
+}
+
+uint32_t Object::get_edited_version() const {
+	return _edited_version;
+}
+#endif
+
+void *Object::get_script_instance_binding(int p_script_language_index) {
+#ifdef DEBUG_ENABLED
+	ERR_FAIL_INDEX_V(p_script_language_index, MAX_SCRIPT_INSTANCE_BINDINGS, nullptr);
+#endif
+
+	//it's up to the script language to make this thread safe, if the function is called twice due to threads being out of syncro
+	//just return the same pointer.
+	//if you want to put a big lock in the entire function and keep allocated pointers in a map or something, feel free to do it
+	//as it should not really affect performance much (won't be called too often), as in far most caes the condition below will be false afterwards
+
+	if (!_script_instance_bindings[p_script_language_index]) {
+		void *script_data = ScriptServer::get_language(p_script_language_index)->alloc_instance_binding_data(this);
+		if (script_data) {
+			atomic_increment(&instance_binding_count);
+			_script_instance_bindings[p_script_language_index] = script_data;
+		}
+	}
+
+	return _script_instance_bindings[p_script_language_index];
+}
+
+bool Object::has_script_instance_binding(int p_script_language_index) {
+	return _script_instance_bindings[p_script_language_index] != nullptr;
+}
+
+void Object::set_script_instance_binding(int p_script_language_index, void *p_data) {
+#ifdef DEBUG_ENABLED
+	CRASH_COND(_script_instance_bindings[p_script_language_index] != nullptr);
+#endif
+	_script_instance_bindings[p_script_language_index] = p_data;
+}
+
+void Object::_construct_object(bool p_reference) {
+	type_is_reference = p_reference;
+	_instance_id = ObjectDB::add_instance(this);
+	memset(_script_instance_bindings, 0, sizeof(void *) * MAX_SCRIPT_INSTANCE_BINDINGS);
+
+#ifdef DEBUG_ENABLED
+	_lock_index.init(1);
+#endif
+}
+
+Object::Object(bool p_reference) {
+	_construct_object(p_reference);
+}
+
+Object::Object() {
+	_construct_object(false);
+}
+
+Object::~Object() {
+	if (script_instance) {
+		memdelete(script_instance);
+	}
+	script_instance = nullptr;
+
+	const StringName *S = nullptr;
+
+	if (_emitting) {
+		//@todo this may need to actually reach the debugger prioritarily somehow because it may crash before
+		ERR_PRINT("Object " + to_string() + " was freed or unreferenced while a signal is being emitted from it. Try connecting to the signal using 'CONNECT_DEFERRED' flag, or use queue_free() to free the object (if this object is a Node) to avoid this error and potential crashes.");
+	}
+
+	while ((S = signal_map.next(nullptr))) {
+		SignalData *s = &signal_map[*S];
+
+		//brute force disconnect for performance
+		int slot_count = s->slot_map.size();
+		const VMap<Callable, SignalData::Slot>::Pair *slot_list = s->slot_map.get_array();
+
+		for (int i = 0; i < slot_count; i++) {
+			slot_list[i].value.conn.callable.get_object()->connections.erase(slot_list[i].value.cE);
+		}
+
+		signal_map.erase(*S);
+	}
+
+	//signals from nodes that connect to this node
+	while (connections.size()) {
+		Connection c = connections.front()->get();
+		c.signal.get_object()->_disconnect(c.signal.get_name(), c.callable, true);
+	}
+
+	ObjectDB::remove_instance(this);
+	_instance_id = ObjectID();
+	_predelete_ok = 2;
+
+	if (!ScriptServer::are_languages_finished()) {
+		for (int i = 0; i < MAX_SCRIPT_INSTANCE_BINDINGS; i++) {
+			if (_script_instance_bindings[i]) {
+				ScriptServer::get_language(i)->free_instance_binding_data(_script_instance_bindings[i]);
+			}
+		}
+	}
+}
+
+bool predelete_handler(Object *p_object) {
+	return p_object->_predelete();
+}
+
+void postinitialize_handler(Object *p_object) {
+	p_object->_postinitialize();
+}
+
+void ObjectDB::debug_objects(DebugFunc p_func) {
+	spin_lock.lock();
+	for (uint32_t i = 0; i < slot_count; i++) {
+		uint32_t slot = object_slots[i].next_free;
+		p_func(object_slots[slot].object);
+	}
+	spin_lock.unlock();
+}
+
+void Object::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
+}
+
+SpinLock ObjectDB::spin_lock;
+uint32_t ObjectDB::slot_count = 0;
+uint32_t ObjectDB::slot_max = 0;
+ObjectDB::ObjectSlot *ObjectDB::object_slots = nullptr;
+uint64_t ObjectDB::validator_counter = 0;
+
+int ObjectDB::get_object_count() {
+	return slot_count;
+}
+
+ObjectID ObjectDB::add_instance(Object *p_object) {
+	spin_lock.lock();
+	if (unlikely(slot_count == slot_max)) {
+		CRASH_COND(slot_count == (1 << OBJECTDB_SLOT_MAX_COUNT_BITS));
+
+		uint32_t new_slot_max = slot_max > 0 ? slot_max * 2 : 1;
+		object_slots = (ObjectSlot *)memrealloc(object_slots, sizeof(ObjectSlot) * new_slot_max);
+		for (uint32_t i = slot_max; i < new_slot_max; i++) {
+			object_slots[i].object = nullptr;
+			object_slots[i].is_reference = false;
+			object_slots[i].next_free = i;
+			object_slots[i].validator = 0;
+		}
+		slot_max = new_slot_max;
+	}
+
+	uint32_t slot = object_slots[slot_count].next_free;
+	if (object_slots[slot].object != nullptr) {
+		spin_lock.unlock();
+		ERR_FAIL_COND_V(object_slots[slot].object != nullptr, ObjectID());
+	}
+	object_slots[slot].object = p_object;
+	object_slots[slot].is_reference = p_object->is_reference();
+	validator_counter = (validator_counter + 1) & OBJECTDB_VALIDATOR_MASK;
+	if (unlikely(validator_counter == 0)) {
+		validator_counter = 1;
+	}
+	object_slots[slot].validator = validator_counter;
+
+	uint64_t id = validator_counter;
+	id <<= OBJECTDB_SLOT_MAX_COUNT_BITS;
+	id |= uint64_t(slot);
+
+	if (p_object->is_reference()) {
+		id |= OBJECTDB_REFERENCE_BIT;
+	}
+
+	slot_count++;
+
+	spin_lock.unlock();
+
+	return ObjectID(id);
+}
+
+void ObjectDB::remove_instance(Object *p_object) {
+	uint64_t t = p_object->get_instance_id();
+	uint32_t slot = t & OBJECTDB_SLOT_MAX_COUNT_MASK; //slot is always valid on valid object
+
+	spin_lock.lock();
+
+#ifdef DEBUG_ENABLED
+
+	if (object_slots[slot].object != p_object) {
+		spin_lock.unlock();
+		ERR_FAIL_COND(object_slots[slot].object != p_object);
+	}
+	{
+		uint64_t validator = (t >> OBJECTDB_SLOT_MAX_COUNT_BITS) & OBJECTDB_VALIDATOR_MASK;
+		if (object_slots[slot].validator != validator) {
+			spin_lock.unlock();
+			ERR_FAIL_COND(object_slots[slot].validator != validator);
+		}
+	}
+
+#endif
+	//decrease slot count
+	slot_count--;
+	//set the free slot properly
+	object_slots[slot_count].next_free = slot;
+	//invalidate, so checks against it fail
+	object_slots[slot].validator = 0;
+	object_slots[slot].is_reference = false;
+	object_slots[slot].object = nullptr;
+
+	spin_lock.unlock();
+}
+
+void ObjectDB::setup() {
+	//nothing to do now
+}
+
+void ObjectDB::cleanup() {
+	if (slot_count > 0) {
+		spin_lock.lock();
+
+		WARN_PRINT("ObjectDB instances leaked at exit (run with --verbose for details).");
+		if (OS::get_singleton()->is_stdout_verbose()) {
+			// Ensure calling the native classes because if a leaked instance has a script
+			// that overrides any of those methods, it'd not be OK to call them at this point,
+			// now the scripting languages have already been terminated.
+			MethodBind *node_get_name = ClassDB::get_method("Node", "get_name");
+			MethodBind *resource_get_path = ClassDB::get_method("Resource", "get_path");
+			Callable::CallError call_error;
+
+			for (uint32_t i = 0; i < slot_count; i++) {
+				uint32_t slot = object_slots[i].next_free;
+				Object *obj = object_slots[slot].object;
+
+				String extra_info;
+				if (obj->is_class("Node")) {
+					extra_info = " - Node name: " + String(node_get_name->call(obj, nullptr, 0, call_error));
+				}
+				if (obj->is_class("Resource")) {
+					extra_info = " - Resource path: " + String(resource_get_path->call(obj, nullptr, 0, call_error));
+				}
+
+				uint64_t id = uint64_t(slot) | (uint64_t(object_slots[slot].validator) << OBJECTDB_VALIDATOR_BITS) | (object_slots[slot].is_reference ? OBJECTDB_REFERENCE_BIT : 0);
+				print_line("Leaked instance: " + String(obj->get_class()) + ":" + itos(id) + extra_info);
+			}
+			print_line("Hint: Leaked instances typically happen when nodes are removed from the scene tree (with `remove_child()`) but not freed (with `free()` or `queue_free()`).");
+		}
+		spin_lock.unlock();
+	}
+
+	if (object_slots) {
+		memfree(object_slots);
+	}
+}
-- 
cgit v1.2.3