godot/modules/nativescript/nativescript.cpp
Karroffel 3185c9c374 [NativeScript] fixed optional _init call
In 3c53b35 a call to an "_init" function was introduced,
that however was only executed in the `_new` function,
also it *required* that such a function exists.

With this patch the "_init" function will be optionally called on
every instance creation.
2017-07-27 15:30:39 +02:00

1229 lines
33 KiB
C++

/*************************************************************************/
/* nativescript.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 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 "nativescript.h"
#include "modules/gdnative/godot/gdnative.h"
#include "global_constants.h"
#include "io/file_access_encrypted.h"
#include "os/file_access.h"
#include "os/os.h"
#include "project_settings.h"
#include "scene/main/scene_tree.h"
#include "scene/resources/scene_format_text.h"
#ifndef NO_THREADS
#include "os/thread.h"
#endif
#if defined(TOOLS_ENABLED) && defined(DEBUG_METHODS_ENABLED)
#include "api_generator.h"
#endif
#ifdef TOOLS_ENABLED
#include "editor/editor_node.h"
#endif
////// Script stuff
void NativeScript::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_class_name", "class_name:String"), &NativeScript::set_class_name);
ClassDB::bind_method(D_METHOD("get_class_name:String"), &NativeScript::get_class_name);
ClassDB::bind_method(D_METHOD("set_library", "library:GDNativeLibrary"), &NativeScript::set_library);
ClassDB::bind_method(D_METHOD("get_library:GDNativeLibrary"), &NativeScript::get_library);
ADD_PROPERTYNZ(PropertyInfo(Variant::STRING, "class_name"), "set_class_name", "get_class_name");
ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "GDNativeLibrary"), "set_library", "get_library");
ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &NativeScript::_new, MethodInfo(Variant::OBJECT, "new"));
}
#define NSL NativeScriptLanguage::get_singleton()
#ifdef TOOLS_ENABLED
void NativeScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
NativeScriptDesc *script_data = get_script_desc();
ERR_FAIL_COND(!script_data);
List<PropertyInfo> info;
Map<StringName, Variant> values;
for (Map<StringName, NativeScriptDesc::Property>::Element *E = script_data->properties.front(); E; E = E->next()) {
PropertyInfo p = E->get().info;
p.name = String(E->key());
info.push_back(p);
values[p.name] = E->get().default_value;
}
p_placeholder->update(info, values);
}
void NativeScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
placeholders.erase(p_placeholder);
}
#endif
void NativeScript::set_class_name(String p_class_name) {
class_name = p_class_name;
}
String NativeScript::get_class_name() const {
return class_name;
}
void NativeScript::set_library(Ref<GDNativeLibrary> p_library) {
if (!library.is_null()) {
WARN_PRINT("library on NativeScript already set. Do nothing.");
return;
}
library = p_library;
lib_path = library->get_active_library_path();
#ifndef NO_THREADS
if (Thread::get_caller_ID() != Thread::get_main_ID()) {
NSL->defer_init_library(p_library, this);
} else
#endif
{
NSL->init_library(p_library);
NSL->register_script(this);
}
}
Ref<GDNativeLibrary> NativeScript::get_library() const {
return library;
}
bool NativeScript::can_instance() const {
NativeScriptDesc *script_data = get_script_desc();
#ifdef TOOLS_ENABLED
return script_data || (!is_tool() && !ScriptServer::is_scripting_enabled());
#else
return script_data;
#endif
}
// TODO(karroffel): implement this
Ref<Script> NativeScript::get_base_script() const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return Ref<Script>();
Ref<NativeScript> ns = Ref<NativeScript>(NSL->create_script());
ns->set_class_name(script_data->base);
ns->set_library(get_library());
return ns;
}
StringName NativeScript::get_instance_base_type() const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return "";
return script_data->base_native_type;
}
ScriptInstance *NativeScript::instance_create(Object *p_this) {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data) {
return NULL;
}
#ifdef TOOLS_ENABLED
if (!ScriptServer::is_scripting_enabled() && !is_tool()) {
// placeholder for nodes. For tools we want the rool thing.
PlaceHolderScriptInstance *sins = memnew(PlaceHolderScriptInstance(NSL, Ref<Script>(this), p_this));
placeholders.insert(sins);
if (script_data->create_func.create_func) {
script_data->create_func.create_func(
(godot_object *)p_this,
script_data->create_func.method_data);
}
_update_placeholder(sins);
return sins;
}
#endif
NativeScriptInstance *nsi = memnew(NativeScriptInstance);
nsi->owner = p_this;
nsi->script = Ref<NativeScript>(this);
#ifndef TOOLS_ENABLED
if (!ScriptServer::is_scripting_enabled()) {
nsi->userdata = NULL;
} else {
nsi->userdata = script_data->create_func.create_func((godot_object *)p_this, script_data->create_func.method_data);
}
#else
nsi->userdata = script_data->create_func.create_func((godot_object *)p_this, script_data->create_func.method_data);
#endif
#ifndef NO_THREADS
owners_lock->lock();
#endif
instance_owners.insert(p_this);
#ifndef NO_THREADS
owners_lock->unlock();
#endif
// try to call _init
// we don't care if it doesn't exist, so we ignore errors.
Variant::CallError err;
call("_init", NULL, 0, err);
return nsi;
}
bool NativeScript::instance_has(const Object *p_this) const {
return instance_owners.has((Object *)p_this);
}
bool NativeScript::has_source_code() const {
return false;
}
String NativeScript::get_source_code() const {
return "";
}
void NativeScript::set_source_code(const String &p_code) {
}
Error NativeScript::reload(bool p_keep_state) {
return FAILED;
}
bool NativeScript::has_method(const StringName &p_method) const {
NativeScriptDesc *script_data = get_script_desc();
while (script_data) {
if (script_data->methods.has(p_method))
return true;
script_data = script_data->base_data;
}
return false;
}
MethodInfo NativeScript::get_method_info(const StringName &p_method) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return MethodInfo();
while (script_data) {
Map<StringName, NativeScriptDesc::Method>::Element *M = script_data->methods.find(p_method);
if (M)
return M->get().info;
script_data = script_data->base_data;
}
return MethodInfo();
}
bool NativeScript::is_tool() const {
NativeScriptDesc *script_data = get_script_desc();
if (script_data)
return script_data->is_tool;
return false;
}
String NativeScript::get_node_type() const {
return ""; // NOTE(karroffel): uhm?
}
ScriptLanguage *NativeScript::get_language() const {
return NativeScriptLanguage::get_singleton();
}
bool NativeScript::has_script_signal(const StringName &p_signal) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return false;
return script_data->signals_.has(p_signal);
}
void NativeScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return;
Set<MethodInfo> signals_;
while (script_data) {
for (Map<StringName, NativeScriptDesc::Signal>::Element *S = script_data->signals_.front(); S; S = S->next()) {
signals_.insert(S->get().signal);
}
script_data = script_data->base_data;
}
for (Set<MethodInfo>::Element *E = signals_.front(); E; E = E->next()) {
r_signals->push_back(E->get());
}
}
bool NativeScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return false;
Map<StringName, NativeScriptDesc::Property>::Element *P = script_data->properties.find(p_property);
if (!P)
return false;
r_value = P->get().default_value;
return true;
}
void NativeScript::update_exports() {
}
void NativeScript::get_script_method_list(List<MethodInfo> *p_list) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return;
Set<MethodInfo> methods;
while (script_data) {
for (Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.front(); E; E = E->next()) {
methods.insert(E->get().info);
}
script_data = script_data->base_data;
}
for (Set<MethodInfo>::Element *E = methods.front(); E; E = E->next()) {
p_list->push_back(E->get());
}
}
void NativeScript::get_script_property_list(List<PropertyInfo> *p_list) const {
NativeScriptDesc *script_data = get_script_desc();
if (!script_data)
return;
Set<PropertyInfo> properties;
while (script_data) {
for (Map<StringName, NativeScriptDesc::Property>::Element *E = script_data->properties.front(); E; E = E->next()) {
properties.insert(E->get().info);
}
script_data = script_data->base_data;
}
for (Set<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) {
p_list->push_back(E->get());
}
}
Variant NativeScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
if (lib_path.empty() || class_name.empty() || library.is_null()) {
r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return Variant();
}
NativeScriptDesc *script_data = get_script_desc();
if (!script_data) {
r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return Variant();
}
r_error.error = Variant::CallError::CALL_OK;
REF ref;
Object *owner = NULL;
if (!(script_data->base_native_type == "")) {
owner = ClassDB::instance(script_data->base_native_type);
} else {
owner = memnew(Reference);
}
Reference *r = owner->cast_to<Reference>();
if (r) {
ref = REF(r);
}
NativeScriptInstance *instance = (NativeScriptInstance *)instance_create(owner);
owner->set_script_instance(instance);
if (!instance) {
if (ref.is_null()) {
memdelete(owner); //no owner, sorry
}
return Variant();
}
if (ref.is_valid()) {
return ref;
} else {
return owner;
}
}
// TODO(karroffel): implement this
NativeScript::NativeScript() {
library = Ref<GDNative>();
lib_path = "";
class_name = "";
#ifndef NO_THREADS
owners_lock = Mutex::create();
#endif
}
// TODO(karroffel): implement this
NativeScript::~NativeScript() {
NSL->unregister_script(this);
#ifndef NO_THREADS
memdelete(owners_lock);
#endif
}
////// ScriptInstance stuff
#define GET_SCRIPT_DESC() script->get_script_desc()
void NativeScriptInstance::_ml_call_reversed(NativeScriptDesc *script_data, const StringName &p_method, const Variant **p_args, int p_argcount) {
if (script_data->base_data) {
_ml_call_reversed(script_data->base_data, p_method, p_args, p_argcount);
}
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find(p_method);
if (E) {
godot_variant res = E->get().method.method((godot_object *)owner, E->get().method.method_data, userdata, p_argcount, (godot_variant **)p_args);
godot_variant_destroy(&res);
}
}
bool NativeScriptInstance::set(const StringName &p_name, const Variant &p_value) {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Property>::Element *P = script_data->properties.find(p_name);
if (P) {
P->get().setter.set_func((godot_object *)owner,
P->get().setter.method_data,
userdata,
(godot_variant *)&p_value);
return true;
}
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find("_set");
if (E) {
Variant name = p_name;
const Variant *args[2] = { &name, &p_value };
E->get().method.method((godot_object *)owner,
E->get().method.method_data,
userdata,
2,
(godot_variant **)args);
return true;
}
script_data = script_data->base_data;
}
return false;
}
bool NativeScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Property>::Element *P = script_data->properties.find(p_name);
if (P) {
godot_variant value;
value = P->get().getter.get_func((godot_object *)owner,
P->get().getter.method_data,
userdata);
r_ret = *(Variant *)&value;
godot_variant_destroy(&value);
return true;
}
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find("_get");
if (E) {
Variant name = p_name;
const Variant *args[1] = { &name };
godot_variant result;
result = E->get().method.method((godot_object *)owner,
E->get().method.method_data,
userdata,
1,
(godot_variant **)args);
r_ret = *(Variant *)&result;
godot_variant_destroy(&result);
if (r_ret.get_type() == Variant::NIL) {
return false;
}
return true;
}
script_data = script_data->base_data;
}
return false;
}
void NativeScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
script->get_script_property_list(p_properties);
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find("_get_property_list");
if (E) {
godot_variant result;
result = E->get().method.method((godot_object *)owner,
E->get().method.method_data,
userdata,
0,
NULL);
Variant res = *(Variant *)&result;
godot_variant_destroy(&result);
if (res.get_type() != Variant::ARRAY) {
ERR_EXPLAIN("_get_property_list must return an array of dictionaries");
ERR_FAIL();
}
Array arr = res;
for (int i = 0; i < arr.size(); i++) {
Dictionary d = arr[i];
ERR_CONTINUE(!d.has("name"));
ERR_CONTINUE(!d.has("type"));
PropertyInfo info;
info.type = Variant::Type(d["type"].operator int64_t());
ERR_CONTINUE(info.type < 0 || info.type >= Variant::VARIANT_MAX);
info.name = d["name"];
ERR_CONTINUE(info.name == "");
if (d.has("hint")) {
info.hint = PropertyHint(d["hint"].operator int64_t());
}
if (d.has("hint_string")) {
info.hint_string = d["hint_string"];
}
if (d.has("usage")) {
info.usage = d["usage"];
}
p_properties->push_back(info);
}
}
script_data = script_data->base_data;
}
return;
}
Variant::Type NativeScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Property>::Element *P = script_data->properties.find(p_name);
if (P) {
*r_is_valid = true;
return P->get().info.type;
}
script_data = script_data->base_data;
}
return Variant::NIL;
}
void NativeScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
script->get_method_list(p_list);
}
bool NativeScriptInstance::has_method(const StringName &p_method) const {
return script->has_method(p_method);
}
Variant NativeScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find(p_method);
if (E) {
godot_variant result;
result = E->get().method.method((godot_object *)owner,
E->get().method.method_data,
userdata,
p_argcount,
(godot_variant **)p_args);
Variant res = *(Variant *)&result;
godot_variant_destroy(&result);
r_error.error = Variant::CallError::CALL_OK;
return res;
}
script_data = script_data->base_data;
}
r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
return Variant();
}
void NativeScriptInstance::notification(int p_notification) {
Variant value = p_notification;
const Variant *args[1] = { &value };
call_multilevel("_notification", args, 1);
}
void NativeScriptInstance::refcount_incremented() {
Variant::CallError err;
call("_refcount_incremented", NULL, 0, err);
if (err.error != Variant::CallError::CALL_OK && err.error != Variant::CallError::CALL_ERROR_INVALID_METHOD) {
ERR_PRINT("Failed to invoke _refcount_incremented - should not happen");
}
}
bool NativeScriptInstance::refcount_decremented() {
Variant::CallError err;
Variant ret = call("_refcount_decremented", NULL, 0, err);
if (err.error != Variant::CallError::CALL_OK && err.error != Variant::CallError::CALL_ERROR_INVALID_METHOD) {
ERR_PRINT("Failed to invoke _refcount_decremented - should not happen");
return true; // assume we can destroy the object
}
if (err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
// the method does not exist, default is true
return true;
}
return ret;
}
Ref<Script> NativeScriptInstance::get_script() const {
return script;
}
NativeScriptInstance::RPCMode NativeScriptInstance::get_rpc_mode(const StringName &p_method) const {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find(p_method);
if (E) {
switch (E->get().rpc_mode) {
case GODOT_METHOD_RPC_MODE_DISABLED:
return RPC_MODE_DISABLED;
case GODOT_METHOD_RPC_MODE_REMOTE:
return RPC_MODE_REMOTE;
case GODOT_METHOD_RPC_MODE_SYNC:
return RPC_MODE_SYNC;
case GODOT_METHOD_RPC_MODE_MASTER:
return RPC_MODE_MASTER;
case GODOT_METHOD_RPC_MODE_SLAVE:
return RPC_MODE_SLAVE;
default:
return RPC_MODE_DISABLED;
}
}
script_data = script_data->base_data;
}
return RPC_MODE_DISABLED;
}
// TODO(karroffel): implement this
NativeScriptInstance::RPCMode NativeScriptInstance::get_rset_mode(const StringName &p_variable) const {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Property>::Element *E = script_data->properties.find(p_variable);
if (E) {
switch (E->get().rset_mode) {
case GODOT_METHOD_RPC_MODE_DISABLED:
return RPC_MODE_DISABLED;
case GODOT_METHOD_RPC_MODE_REMOTE:
return RPC_MODE_REMOTE;
case GODOT_METHOD_RPC_MODE_SYNC:
return RPC_MODE_SYNC;
case GODOT_METHOD_RPC_MODE_MASTER:
return RPC_MODE_MASTER;
case GODOT_METHOD_RPC_MODE_SLAVE:
return RPC_MODE_SLAVE;
default:
return RPC_MODE_DISABLED;
}
}
script_data = script_data->base_data;
}
return RPC_MODE_DISABLED;
}
ScriptLanguage *NativeScriptInstance::get_language() {
return NativeScriptLanguage::get_singleton();
}
void NativeScriptInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
while (script_data) {
Map<StringName, NativeScriptDesc::Method>::Element *E = script_data->methods.find(p_method);
if (E) {
godot_variant res = E->get().method.method((godot_object *)owner,
E->get().method.method_data,
userdata,
p_argcount,
(godot_variant **)p_args);
godot_variant_destroy(&res);
}
script_data = script_data->base_data;
}
}
void NativeScriptInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
if (script_data) {
_ml_call_reversed(script_data, p_method, p_args, p_argcount);
}
}
NativeScriptInstance::~NativeScriptInstance() {
NativeScriptDesc *script_data = GET_SCRIPT_DESC();
if (!script_data)
return;
script_data->destroy_func.destroy_func((godot_object *)owner, script_data->destroy_func.method_data, userdata);
if (owner) {
#ifndef NO_THREADS
script->owners_lock->lock();
#endif
script->instance_owners.erase(owner);
#ifndef NO_THREADS
script->owners_lock->unlock();
#endif
}
}
////// ScriptingLanguage stuff
NativeScriptLanguage *NativeScriptLanguage::singleton;
extern "C" void _native_script_hook();
void NativeScriptLanguage::_hacky_api_anchor() {
_native_script_hook();
}
void NativeScriptLanguage::_unload_stuff() {
for (Map<String, Map<StringName, NativeScriptDesc> >::Element *L = library_classes.front(); L; L = L->next()) {
for (Map<StringName, NativeScriptDesc>::Element *C = L->get().front(); C; C = C->next()) {
// free property stuff first
for (Map<StringName, NativeScriptDesc::Property>::Element *P = C->get().properties.front(); P; P = P->next()) {
if (P->get().getter.free_func)
P->get().getter.free_func(P->get().getter.method_data);
if (P->get().setter.free_func)
P->get().setter.free_func(P->get().setter.method_data);
}
// free method stuff
for (Map<StringName, NativeScriptDesc::Method>::Element *M = C->get().methods.front(); M; M = M->next()) {
if (M->get().method.free_func)
M->get().method.free_func(M->get().method.method_data);
}
// free constructor/destructor
if (C->get().create_func.free_func)
C->get().create_func.free_func(C->get().create_func.method_data);
if (C->get().destroy_func.free_func)
C->get().destroy_func.free_func(C->get().destroy_func.method_data);
}
}
}
NativeScriptLanguage::NativeScriptLanguage() {
NativeScriptLanguage::singleton = this;
#ifndef NO_THREADS
mutex = Mutex::create();
#endif
}
// TODO(karroffel): implement this
NativeScriptLanguage::~NativeScriptLanguage() {
// _unload_stuff(); // NOTE(karroffel): This gets called in ::finish()
for (Map<String, Ref<GDNative> >::Element *L = NSL->library_gdnatives.front(); L; L = L->next()) {
L->get()->terminate();
NSL->library_classes.clear();
NSL->library_gdnatives.clear();
NSL->library_script_users.clear();
}
#ifndef NO_THREADS
memdelete(mutex);
#endif
}
String NativeScriptLanguage::get_name() const {
return "NativeScript";
}
void _add_reload_node() {
#ifdef TOOLS_ENABLED
NativeReloadNode *rn = memnew(NativeReloadNode);
EditorNode::get_singleton()->add_child(rn);
#endif
}
// TODO(karroffel): implement this
void NativeScriptLanguage::init() {
#if defined(TOOLS_ENABLED) && defined(DEBUG_METHODS_ENABLED)
List<String> args = OS::get_singleton()->get_cmdline_args();
List<String>::Element *E = args.find("--gdnative-generate-json-api");
if (E && E->next()) {
if (generate_c_api(E->next()->get()) != OK) {
ERR_PRINT("Failed to generate C API\n");
}
}
#endif
#ifdef TOOLS_ENABLED
EditorNode::add_init_callback(&_add_reload_node);
#endif
}
String NativeScriptLanguage::get_type() const {
return "NativeScript";
}
String NativeScriptLanguage::get_extension() const {
return "gdns";
}
Error NativeScriptLanguage::execute_file(const String &p_path) {
return OK; // Qué?
}
void NativeScriptLanguage::finish() {
_unload_stuff();
}
void NativeScriptLanguage::get_reserved_words(List<String> *p_words) const {
}
void NativeScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
}
void NativeScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
}
// TODO(karroffel): implement this
Ref<Script> NativeScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
NativeScript *s = memnew(NativeScript);
s->set_class_name(p_class_name);
// TODO(karroffel): use p_base_class_name
return Ref<NativeScript>(s);
}
bool NativeScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions) const {
return false;
}
Script *NativeScriptLanguage::create_script() const {
NativeScript *script = memnew(NativeScript);
return script;
}
bool NativeScriptLanguage::has_named_classes() const {
return true;
}
int NativeScriptLanguage::find_function(const String &p_function, const String &p_code) const {
return -1;
}
String NativeScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
return "";
}
void NativeScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
}
void NativeScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
}
// Debugging stuff here. Not used for now.
String NativeScriptLanguage::debug_get_error() const {
return "";
}
int NativeScriptLanguage::debug_get_stack_level_count() const {
return -1;
}
int NativeScriptLanguage::debug_get_stack_level_line(int p_level) const {
return -1;
}
String NativeScriptLanguage::debug_get_stack_level_function(int p_level) const {
return "";
}
String NativeScriptLanguage::debug_get_stack_level_source(int p_level) const {
return "";
}
void NativeScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
}
void NativeScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
}
void NativeScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
}
String NativeScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
return "";
}
// Debugging stuff end.
void NativeScriptLanguage::reload_all_scripts() {
}
void NativeScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
}
void NativeScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("gdns");
}
void NativeScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
}
void NativeScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
}
void NativeScriptLanguage::profiling_start() {
}
void NativeScriptLanguage::profiling_stop() {
}
int NativeScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
return -1;
}
int NativeScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
return -1;
}
#ifndef NO_THREADS
void NativeScriptLanguage::defer_init_library(Ref<GDNativeLibrary> lib, NativeScript *script) {
MutexLock lock(mutex);
libs_to_init.insert(lib);
scripts_to_register.insert(script);
has_objects_to_register = true;
}
#endif
void NativeScriptLanguage::init_library(const Ref<GDNativeLibrary> &lib) {
#ifndef NO_THREADS
MutexLock lock(mutex);
#endif
// See if this library was "registered" already.
const String &lib_path = lib->get_active_library_path();
Map<String, Ref<GDNative> >::Element *E = library_gdnatives.find(lib_path);
if (!E) {
Ref<GDNative> gdn;
gdn.instance();
gdn->set_library(lib);
// TODO(karroffel): check the return value?
gdn->initialize();
library_gdnatives.insert(lib_path, gdn);
library_classes.insert(lib_path, Map<StringName, NativeScriptDesc>());
if (!library_script_users.has(lib_path))
library_script_users.insert(lib_path, Set<NativeScript *>());
void *args[1] = {
(void *)&lib_path
};
// here the library registers all the classes and stuff.
gdn->call_native_raw(_init_call_type,
_init_call_name,
NULL,
1,
args,
NULL);
} else {
// already initialized. Nice.
}
}
void NativeScriptLanguage::register_script(NativeScript *script) {
#ifndef NO_THREADS
MutexLock lock(mutex);
#endif
library_script_users[script->lib_path].insert(script);
}
void NativeScriptLanguage::unregister_script(NativeScript *script) {
#ifndef NO_THREADS
MutexLock lock(mutex);
#endif
Map<String, Set<NativeScript *> >::Element *S = library_script_users.find(script->lib_path);
if (S) {
S->get().erase(script);
if (S->get().size() == 0) {
library_script_users.erase(S);
}
}
#ifndef NO_THREADS
scripts_to_register.erase(script);
#endif
}
#ifndef NO_THREADS
void NativeScriptLanguage::frame() {
if (has_objects_to_register) {
MutexLock lock(mutex);
for (Set<Ref<GDNativeLibrary> >::Element *L = libs_to_init.front(); L; L = L->next()) {
init_library(L->get());
}
libs_to_init.clear();
for (Set<NativeScript *>::Element *S = scripts_to_register.front(); S; S = S->next()) {
register_script(S->get());
}
scripts_to_register.clear();
has_objects_to_register = false;
}
}
void NativeScriptLanguage::thread_enter() {
Vector<Ref<GDNative> > libs;
{
MutexLock lock(mutex);
for (Map<String, Ref<GDNative> >::Element *L = library_gdnatives.front(); L; L = L->next()) {
libs.push_back(L->get());
}
}
for (int i = 0; i < libs.size(); ++i) {
libs[i]->call_native_raw(
_thread_cb_call_type,
_thread_enter_call_name,
NULL,
0,
NULL,
NULL);
}
}
void NativeScriptLanguage::thread_exit() {
Vector<Ref<GDNative> > libs;
{
MutexLock lock(mutex);
for (Map<String, Ref<GDNative> >::Element *L = library_gdnatives.front(); L; L = L->next()) {
libs.push_back(L->get());
}
}
for (int i = 0; i < libs.size(); ++i) {
libs[i]->call_native_raw(
_thread_cb_call_type,
_thread_exit_call_name,
NULL,
0,
NULL,
NULL);
}
}
#endif // NO_THREADS
void NativeReloadNode::_bind_methods() {
ClassDB::bind_method(D_METHOD("_notification"), &NativeReloadNode::_notification);
}
void NativeReloadNode::_notification(int p_what) {
#ifdef TOOLS_ENABLED
switch (p_what) {
case MainLoop::NOTIFICATION_WM_FOCUS_OUT: {
if (unloaded)
break;
#ifndef NO_THREADS
MutexLock lock(NSL->mutex);
#endif
NSL->_unload_stuff();
for (Map<String, Ref<GDNative> >::Element *L = NSL->library_gdnatives.front(); L; L = L->next()) {
L->get()->terminate();
NSL->library_classes.erase(L->key());
}
unloaded = true;
} break;
case MainLoop::NOTIFICATION_WM_FOCUS_IN: {
if (!unloaded)
break;
#ifndef NO_THREADS
MutexLock lock(NSL->mutex);
#endif
Set<StringName> libs_to_remove;
for (Map<String, Ref<GDNative> >::Element *L = NSL->library_gdnatives.front(); L; L = L->next()) {
if (!L->get()->initialize()) {
libs_to_remove.insert(L->key());
continue;
}
NSL->library_classes.insert(L->key(), Map<StringName, NativeScriptDesc>());
void *args[1] = {
(void *)&L->key()
};
// here the library registers all the classes and stuff.
L->get()->call_native_raw(NSL->_init_call_type,
NSL->_init_call_name,
NULL,
1,
args,
NULL);
for (Map<String, Set<NativeScript *> >::Element *U = NSL->library_script_users.front(); U; U = U->next()) {
for (Set<NativeScript *>::Element *S = U->get().front(); S; S = S->next()) {
NativeScript *script = S->get();
if (script->placeholders.size() == 0)
continue;
for (Set<PlaceHolderScriptInstance *>::Element *P = script->placeholders.front(); P; P = P->next()) {
script->_update_placeholder(P->get());
}
}
}
}
unloaded = false;
for (Set<StringName>::Element *R = libs_to_remove.front(); R; R = R->next()) {
NSL->library_gdnatives.erase(R->get());
}
} break;
default: {
};
}
#endif
}
RES ResourceFormatLoaderNativeScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
ResourceFormatLoaderText rsflt;
return rsflt.load(p_path, p_original_path, r_error);
}
void ResourceFormatLoaderNativeScript::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back("gdns");
}
bool ResourceFormatLoaderNativeScript::handles_type(const String &p_type) const {
return (p_type == "Script" || p_type == "NativeScript");
}
String ResourceFormatLoaderNativeScript::get_resource_type(const String &p_path) const {
String el = p_path.get_extension().to_lower();
if (el == "gdns")
return "NativeScript";
return "";
}
Error ResourceFormatSaverNativeScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
ResourceFormatSaverText rfst;
return rfst.save(p_path, p_resource, p_flags);
}
bool ResourceFormatSaverNativeScript::recognize(const RES &p_resource) const {
return p_resource->cast_to<NativeScript>() != NULL;
}
void ResourceFormatSaverNativeScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
if (p_resource->cast_to<NativeScript>()) {
p_extensions->push_back("gdns");
}
}