maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

[GDnative] add pluginscript \o/

Browse source
This commit is contained in:
Emmanuel Leblond 2017-10-08 23:47:38 +02:00
parent 0d0cb01f33
commit e715be0f0a
No known key found for this signature in database
GPG key ID: C360860E645EFFC0
20 changed files with 1937 additions and 11 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
modules/gdnative/SCsub
View file

@ -13,6 +13,7 @@ gdn_env.add_source_files(env.modules_sources, "nativescript/*.cpp")
gdn_env.Append(CPPPATH=['#modules/gdnative/include/'])
SConscript("nativearvr/SCsub")
SConscript("pluginscript/SCsub")
def _spaced(e):
return e if e[-1] == '*' else e + ' '
@ -26,6 +27,7 @@ def _build_gdnative_api_struct_header(api):
'#include <gdnative/gdnative.h>',
'#include <nativearvr/godot_nativearvr.h>',
'#include <nativescript/godot_nativescript.h>',
'#include <pluginscript/godot_pluginscript.h>',
'',
'#define GDNATIVE_API_INIT(options) do { extern const godot_gdnative_api_struct *_gdnative_wrapper_api_struct; _gdnative_wrapper_api_struct = options->api_struct; } while (0)',
'',
@ -98,6 +100,7 @@ def _build_gdnative_wrapper_code(api):
'',
'#include <gdnative/gdnative.h>',
'#include <nativescript/godot_nativescript.h>',
'#include <pluginscript/godot_pluginscript.h>',
'',
'#include <gdnative_api_struct.gen.h>',
'',

4
modules/gdnative/gdnative/string.cpp
View file

@ -29,9 +29,9 @@
/*************************************************************************/
#include "gdnative/string.h"
#include "core/string_db.h"
#include "core/ustring.h"
#include "core/variant.h"
#include "string_db.h"
#include "ustring.h"
#include <string.h>

170
modules/gdnative/include/pluginscript/godot_pluginscript.h Normal file
View file

@ -0,0 +1,170 @@
/*************************************************************************/
/* godot_nativescript.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://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. */
/*************************************************************************/
#ifndef GODOT_PLUGINSCRIPT_H
#define GODOT_PLUGINSCRIPT_H
#include <gdnative/gdnative.h>
#include <nativescript/godot_nativescript.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void godot_pluginscript_instance_data;
typedef void godot_pluginscript_script_data;
typedef void godot_pluginscript_language_data;
// --- Instance ---
// TODO: use godot_string_name for faster lookup ?
typedef struct {
godot_pluginscript_instance_data *(*init)(godot_pluginscript_script_data *p_data, godot_object *p_owner);
void (*finish)(godot_pluginscript_instance_data *p_data);
godot_bool (*set_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, const godot_variant *p_value);
godot_bool (*get_prop)(godot_pluginscript_instance_data *p_data, const godot_string *p_name, godot_variant *r_ret);
godot_variant (*call_method)(godot_pluginscript_instance_data *p_data,
const godot_string_name *p_method, const godot_variant **p_args,
int p_argcount, godot_variant_call_error *r_error);
void (*notification)(godot_pluginscript_instance_data *p_data, int p_notification);
// TODO: could this rpc mode stuff be moved to the godot_pluginscript_script_manifest ?
godot_method_rpc_mode (*get_rpc_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_method);
godot_method_rpc_mode (*get_rset_mode)(godot_pluginscript_instance_data *p_data, const godot_string *p_variable);
//this is used by script languages that keep a reference counter of their own
//you can make make Ref<> not die when it reaches zero, so deleting the reference
//depends entirely from the script.
// Note: You can set thoses function pointer to NULL if not needed.
void (*refcount_incremented)(godot_pluginscript_instance_data *p_data);
bool (*refcount_decremented)(godot_pluginscript_instance_data *p_data); // return true if it can die
} godot_pluginscript_instance_desc;
// --- Script ---
typedef struct {
godot_pluginscript_script_data *data;
godot_string_name name;
godot_bool is_tool;
godot_string_name base;
// Member lines format: {<string>: <int>}
godot_dictionary member_lines;
// Method info dictionary format
// {
// name: <string>
// args: [<dict:property>]
// default_args: [<variant>]
// return: <dict:property>
// flags: <int>
// rpc_mode: <int:godot_method_rpc_mode>
// }
godot_array methods;
// Same format than for methods
godot_array signals;
// Property info dictionary format
// {
// name: <string>
// type: <int:godot_variant_type>
// hint: <int:godot_property_hint>
// hint_string: <string>
// usage: <int:godot_property_usage_flags>
// default_value: <variant>
// rset_mode: <int:godot_method_rpc_mode>
// }
godot_array properties;
} godot_pluginscript_script_manifest;
typedef struct {
godot_pluginscript_script_manifest (*init)(godot_pluginscript_language_data *p_data, const godot_string *p_path, const godot_string *p_source, godot_error *r_error);
void (*finish)(godot_pluginscript_script_data *p_data);
godot_pluginscript_instance_desc instance_desc;
} godot_pluginscript_script_desc;
// --- Language ---
typedef struct {
godot_string_name signature;
godot_int call_count;
godot_int total_time; // In microseconds
godot_int self_time; // In microseconds
} godot_pluginscript_profiling_data;
typedef struct {
const char *name;
const char *type;
const char *extension;
const char **recognized_extensions; // NULL terminated array
godot_pluginscript_language_data *(*init)();
void (*finish)(godot_pluginscript_language_data *p_data);
const char **reserved_words; // NULL terminated array
const char **comment_delimiters; // NULL terminated array
const char **string_delimiters; // NULL terminated array
godot_bool has_named_classes;
godot_string (*get_template_source_code)(godot_pluginscript_language_data *p_data, const godot_string *p_class_name, const godot_string *p_base_class_name);
godot_bool (*validate)(godot_pluginscript_language_data *p_data, const godot_string *p_script, int *r_line_error, int *r_col_error, godot_string *r_test_error, const godot_string *p_path, godot_pool_string_array *r_functions);
int (*find_function)(godot_pluginscript_language_data *p_data, const godot_string *p_function, const godot_string *p_code); // Can be NULL
godot_string (*make_function)(godot_pluginscript_language_data *p_data, const godot_string *p_class, const godot_string *p_name, const godot_pool_string_array *p_args);
godot_error (*complete_code)(godot_pluginscript_language_data *p_data, const godot_string *p_code, const godot_string *p_base_path, godot_object *p_owner, godot_array *r_options, godot_bool *r_force, godot_string *r_call_hint);
void (*auto_indent_code)(godot_pluginscript_language_data *p_data, godot_string *p_code, int p_from_line, int p_to_line);
void (*add_global_constant)(godot_pluginscript_language_data *p_data, const godot_string *p_variable, const godot_variant *p_value);
godot_string (*debug_get_error)(godot_pluginscript_language_data *p_data);
int (*debug_get_stack_level_count)(godot_pluginscript_language_data *p_data);
int (*debug_get_stack_level_line)(godot_pluginscript_language_data *p_data, int p_level);
godot_string (*debug_get_stack_level_function)(godot_pluginscript_language_data *p_data, int p_level);
godot_string (*debug_get_stack_level_source)(godot_pluginscript_language_data *p_data, int p_level);
void (*debug_get_stack_level_locals)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
void (*debug_get_stack_level_members)(godot_pluginscript_language_data *p_data, int p_level, godot_pool_string_array *p_members, godot_array *p_values, int p_max_subitems, int p_max_depth);
void (*debug_get_globals)(godot_pluginscript_language_data *p_data, godot_pool_string_array *p_locals, godot_array *p_values, int p_max_subitems, int p_max_depth);
godot_string (*debug_parse_stack_level_expression)(godot_pluginscript_language_data *p_data, int p_level, const godot_string *p_expression, int p_max_subitems, int p_max_depth);
// TODO: could this stuff be moved to the godot_pluginscript_language_desc ?
void (*get_public_functions)(godot_pluginscript_language_data *p_data, godot_array *r_functions);
void (*get_public_constants)(godot_pluginscript_language_data *p_data, godot_dictionary *r_constants);
void (*profiling_start)(godot_pluginscript_language_data *p_data);
void (*profiling_stop)(godot_pluginscript_language_data *p_data);
int (*profiling_get_accumulated_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
int (*profiling_get_frame_data)(godot_pluginscript_language_data *p_data, godot_pluginscript_profiling_data *r_info, int p_info_max);
void (*profiling_frame)(godot_pluginscript_language_data *p_data);
godot_pluginscript_script_desc script_desc;
} godot_pluginscript_language_desc;
void GDAPI godot_pluginscript_register_language(const godot_pluginscript_language_desc *language_desc);
#ifdef __cplusplus
}
#endif
#endif // GODOT_PLUGINSCRIPT_H

1
modules/gdnative/nativescript/SCsub
View file

@ -4,7 +4,6 @@ Import('env')
mod_env = env.Clone()
mod_env.add_source_files(env.modules_sources, "*.cpp")
mod_env.Append(CPPPATH='#modules/gdnative')
mod_env.Append(CPPFLAGS=['-DGDAPI_BUILT_IN'])
if "platform" in env and env["platform"] in ["x11", "iphone"]:

2
modules/gdnative/nativescript/api_generator.cpp
View file

@ -31,7 +31,7 @@
#ifdef TOOLS_ENABLED
#include "class_db.h"
#include "core/class_db.h"
#include "core/global_constants.h"
#include "core/pair.h"
#include "core/project_settings.h"

2
modules/gdnative/nativescript/api_generator.h
View file

@ -30,8 +30,8 @@
#ifndef API_GENERATOR_H
#define API_GENERATOR_H
#include "core/typedefs.h"
#include "core/ustring.h"
#include "typedefs.h"
Error generate_c_api(const String &p_path);

4
modules/gdnative/nativescript/nativescript.cpp
View file

@ -31,11 +31,11 @@
#include "gdnative/gdnative.h"
#include "global_constants.h"
#include "core/global_constants.h"
#include "core/project_settings.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"

6
modules/gdnative/nativescript/nativescript.h
View file

@ -30,14 +30,14 @@
#ifndef NATIVE_SCRIPT_H
#define NATIVE_SCRIPT_H
#include "core/resource.h"
#include "core/script_language.h"
#include "core/self_list.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
#include "ordered_hash_map.h"
#include "os/thread_safe.h"
#include "resource.h"
#include "scene/main/node.h"
#include "script_language.h"
#include "self_list.h"
#include "modules/gdnative/gdnative.h"
#include <nativescript/godot_nativescript.h>

9
modules/gdnative/pluginscript/SCsub Normal file
View file

@ -0,0 +1,9 @@
#!/usr/bin/env python
Import('env')
Import('env_modules')
env_pluginscript = env_modules.Clone()
env_pluginscript.Append(CPPPATH=['#modules/gdnative/include/'])
env_pluginscript.add_source_files(env.modules_sources, '*.cpp')

181
modules/gdnative/pluginscript/pluginscript_instance.cpp Normal file
View file

@ -0,0 +1,181 @@
/*************************************************************************/
/* pluginscript_instance.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. */
/*************************************************************************/
// Godot imports
#include "core/os/os.h"
#include "core/variant.h"
// PluginScript imports
#include "pluginscript_instance.h"
#include "pluginscript_language.h"
#include "pluginscript_script.h"
bool PluginScriptInstance::set(const StringName &p_name, const Variant &p_value) {
String name = String(p_name);
return _desc->set_prop(_data, (const godot_string *)&name, (const godot_variant *)&p_value);
}
bool PluginScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
String name = String(p_name);
return _desc->get_prop(_data, (const godot_string *)&name, (godot_variant *)&r_ret);
}
Ref<Script> PluginScriptInstance::get_script() const {
return _script;
}
ScriptLanguage *PluginScriptInstance::get_language() {
return _script->get_language();
}
Variant::Type PluginScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
if (!_script->has_property(p_name)) {
if (r_is_valid) {
*r_is_valid = false;
}
return Variant::NIL;
}
if (r_is_valid) {
*r_is_valid = true;
}
return _script->get_property_info(p_name).type;
}
void PluginScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
_script->get_script_property_list(p_properties);
}
void PluginScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
_script->get_script_method_list(p_list);
}
bool PluginScriptInstance::has_method(const StringName &p_method) const {
return _script->has_method(p_method);
}
Variant PluginScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
// TODO: optimize when calling a Godot method from Godot to avoid param conversion ?
godot_variant ret = _desc->call_method(
_data, (godot_string_name *)&p_method, (const godot_variant **)p_args,
p_argcount, (godot_variant_call_error *)&r_error);
Variant *var_ret = (Variant *)&ret;
return *var_ret;
}
#if 0 // TODO: Don't rely on default implementations provided by ScriptInstance ?
void PluginScriptInstance::call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount) {
#if 0
PluginScript *sptr=script.ptr();
Variant::CallError ce;
while(sptr) {
Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
if (E) {
E->get()->call(this,p_args,p_argcount,ce);
}
sptr = sptr->_base;
}
#endif
}
#if 0
void PluginScriptInstance::_ml_call_reversed(PluginScript *sptr,const StringName& p_method,const Variant** p_args,int p_argcount) {
if (sptr->_base)
_ml_call_reversed(sptr->_base,p_method,p_args,p_argcount);
Variant::CallError ce;
Map<StringName,GDFunction*>::Element *E = sptr->member_functions.find(p_method);
if (E) {
E->get()->call(this,p_args,p_argcount,ce);
}
}
#endif
void PluginScriptInstance::call_multilevel_reversed(const StringName& p_method,const Variant** p_args,int p_argcount) {
#if 0
if (script.ptr()) {
_ml_call_reversed(script.ptr(),p_method,p_args,p_argcount);
}
#endif
}
#endif // Multilevel stuff
void PluginScriptInstance::notification(int p_notification) {
_desc->notification(_data, p_notification);
}
ScriptInstance::RPCMode PluginScriptInstance::get_rpc_mode(const StringName &p_method) const {
return _script->get_rpc_mode(p_method);
}
ScriptInstance::RPCMode PluginScriptInstance::get_rset_mode(const StringName &p_variable) const {
return _script->get_rset_mode(p_variable);
}
void PluginScriptInstance::refcount_incremented() {
if (_desc->refcount_decremented) {
_desc->refcount_incremented(_data);
}
}
bool PluginScriptInstance::refcount_decremented() {
// Return true if it can die
if (_desc->refcount_decremented) {
return _desc->refcount_decremented(_data);
}
return true;
}
PluginScriptInstance::PluginScriptInstance() {
}
bool PluginScriptInstance::init(PluginScript *p_script, Object *p_owner) {
_owner = p_owner;
_owner_variant = Variant(p_owner);
_script = Ref<PluginScript>(p_script);
_desc = &p_script->_desc->instance_desc;
_data = _desc->init(p_script->_data, (godot_object *)p_owner);
ERR_FAIL_COND_V(_data == NULL, false);
p_owner->set_script_instance(this);
return true;
}
PluginScriptInstance::~PluginScriptInstance() {
_desc->finish(_data);
_script->_language->lock();
_script->_instances.erase(_owner);
_script->_language->unlock();
}

90
modules/gdnative/pluginscript/pluginscript_instance.h Normal file
View file

@ -0,0 +1,90 @@
/*************************************************************************/
/* pluginscript_instance.h */
/*************************************************************************/
/* 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. */
/*************************************************************************/
#ifndef PLUGINSCRIPT_INSTANCE_H
#define PLUGINSCRIPT_INSTANCE_H
// Godot imports
#include "core/script_language.h"
// PluginScript imports
#include <pluginscript/godot_pluginscript.h>
class PluginScript;
class PluginScriptInstance : public ScriptInstance {
friend class PluginScript;
private:
Ref<PluginScript> _script;
Object *_owner;
Variant _owner_variant;
godot_pluginscript_instance_data *_data;
const godot_pluginscript_instance_desc *_desc;
public:
_FORCE_INLINE_ Object *get_owner() { return _owner; }
virtual bool set(const StringName &p_name, const Variant &p_value);
virtual bool get(const StringName &p_name, Variant &r_ret) const;
virtual void get_property_list(List<PropertyInfo> *p_properties) const;
virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = NULL) const;
virtual void get_method_list(List<MethodInfo> *p_list) const;
virtual bool has_method(const StringName &p_method) const;
virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
#if 0
// Rely on default implementations provided by ScriptInstance for the moment.
// Note that multilevel call could be removed in 3.0 release, so stay tunned
// (see https://godotengine.org/qa/9244/can-override-the-_ready-and-_process-functions-child-classes)
virtual void call_multilevel(const StringName& p_method,const Variant** p_args,int p_argcount);
virtual void call_multilevel_reversed(const StringName& p_method,const Variant** p_args,int p_argcount);
#endif
virtual void notification(int p_notification);
virtual Ref<Script> get_script() const;
virtual ScriptLanguage *get_language();
void set_path(const String &p_path);
virtual RPCMode get_rpc_mode(const StringName &p_method) const;
virtual RPCMode get_rset_mode(const StringName &p_variable) const;
virtual void refcount_incremented();
virtual bool refcount_decremented();
PluginScriptInstance();
bool init(PluginScript *p_script, Object *p_owner);
virtual ~PluginScriptInstance();
};
#endif // PLUGINSCRIPT_INSTANCE_H

432
modules/gdnative/pluginscript/pluginscript_language.cpp Normal file
View file

@ -0,0 +1,432 @@
/*************************************************************************/
/* pluginscript_language.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 <stdlib.h>
// Godot imports
#include "core/os/file_access.h"
#include "core/os/os.h"
#include "core/project_settings.h"
// PluginScript imports
#include "pluginscript_language.h"
#include "pluginscript_script.h"
String PluginScriptLanguage::get_name() const {
return String(_desc.name);
}
void PluginScriptLanguage::init() {
_data = _desc.init();
}
String PluginScriptLanguage::get_type() const {
return String(_desc.type);
}
String PluginScriptLanguage::get_extension() const {
return String(_desc.extension);
}
Error PluginScriptLanguage::execute_file(const String &p_path) {
// TODO: pretty sure this method is totally deprecated and should be removed...
return OK;
}
void PluginScriptLanguage::finish() {
_desc.finish(_data);
}
/* EDITOR FUNCTIONS */
void PluginScriptLanguage::get_reserved_words(List<String> *p_words) const {
if (_desc.reserved_words) {
const char **w = _desc.reserved_words;
while (*w) {
p_words->push_back(*w);
w++;
}
}
}
void PluginScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
if (_desc.comment_delimiters) {
const char **w = _desc.comment_delimiters;
while (*w) {
p_delimiters->push_back(*w);
w++;
}
}
}
void PluginScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
if (_desc.string_delimiters) {
const char **w = _desc.string_delimiters;
while (*w) {
p_delimiters->push_back(*w);
w++;
}
}
}
Ref<Script> PluginScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
Script *ns = create_script();
Ref<Script> script = Ref<Script>(ns);
if (_desc.get_template_source_code) {
godot_string src = _desc.get_template_source_code(_data, (godot_string *)&p_class_name, (godot_string *)&p_base_class_name);
script->set_source_code(*(String *)&src);
}
return script;
}
bool PluginScriptLanguage::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 {
PoolStringArray functions;
if (_desc.validate) {
bool ret = _desc.validate(
_data,
(godot_string *)&p_script,
&r_line_error,
&r_col_error,
(godot_string *)&r_test_error,
(godot_string *)&p_path,
(godot_pool_string_array *)&functions);
for (int i = 0; i < functions.size(); i++) {
r_functions->push_back(functions[i]);
}
return ret;
}
return true;
}
Script *PluginScriptLanguage::create_script() const {
PluginScript *script = memnew(PluginScript());
// I'm hurting kittens doing this I guess...
script->init(const_cast<PluginScriptLanguage *>(this));
return script;
}
bool PluginScriptLanguage::has_named_classes() const {
return _desc.has_named_classes;
}
int PluginScriptLanguage::find_function(const String &p_function, const String &p_code) const {
if (_desc.find_function) {
return _desc.find_function(_data, (godot_string *)&p_function, (godot_string *)&p_code);
}
return -1;
}
String PluginScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
if (_desc.make_function) {
godot_string tmp = _desc.make_function(_data, (godot_string *)&p_class, (godot_string *)&p_name, (godot_pool_string_array *)&p_args);
String ret = *(String *)&tmp;
godot_string_destroy(&tmp);
return ret;
}
return String();
}
Error PluginScriptLanguage::complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, bool &r_force, String &r_call_hint) {
if (_desc.complete_code) {
Array options;
godot_error tmp = _desc.complete_code(
_data,
(godot_string *)&p_code,
(godot_string *)&p_base_path,
(godot_object *)p_owner,
(godot_array *)&options,
&r_force,
(godot_string *)&r_call_hint);
for (int i = 0; i < options.size(); i++) {
r_options->push_back(String(options[i]));
}
Error err = *(Error *)tmp;
return err;
}
return ERR_UNAVAILABLE;
}
void PluginScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
if (_desc.auto_indent_code) {
_desc.auto_indent_code(_data, (godot_string *)&p_code, p_from_line, p_to_line);
}
return;
}
void PluginScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
const String variable = String(p_variable);
_desc.add_global_constant(_data, (godot_string *)&variable, (godot_variant *)&p_value);
}
/* LOADER FUNCTIONS */
void PluginScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
for (int i = 0; _desc.recognized_extensions[i]; ++i) {
p_extensions->push_back(String(_desc.recognized_extensions[i]));
}
}
void PluginScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
// TODO: provid this statically in `godot_pluginscript_language_desc` ?
if (_desc.get_public_functions) {
Array functions;
_desc.get_public_functions(_data, (godot_array *)&functions);
for (int i = 0; i < functions.size(); i++) {
MethodInfo mi = MethodInfo::from_dict(functions[i]);
p_functions->push_back(mi);
}
}
}
void PluginScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
// TODO: provid this statically in `godot_pluginscript_language_desc` ?
if (_desc.get_public_constants) {
Dictionary constants;
_desc.get_public_constants(_data, (godot_dictionary *)&constants);
for (const Variant *key = constants.next(); key; key = constants.next(key)) {
Variant value = constants[key];
p_constants->push_back(Pair<String, Variant>(*key, value));
}
}
}
void PluginScriptLanguage::profiling_start() {
#ifdef DEBUG_ENABLED
if (_desc.profiling_start) {
lock();
_desc.profiling_start(_data);
unlock();
}
#endif
}
void PluginScriptLanguage::profiling_stop() {
#ifdef DEBUG_ENABLED
if (_desc.profiling_stop) {
lock();
_desc.profiling_stop(_data);
unlock();
}
#endif
}
int PluginScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
int info_count = 0;
#ifdef DEBUG_ENABLED
if (_desc.profiling_get_accumulated_data) {
godot_pluginscript_profiling_data *info = (godot_pluginscript_profiling_data *)memalloc(
sizeof(godot_pluginscript_profiling_data) * p_info_max);
info_count = _desc.profiling_get_accumulated_data(_data, info, p_info_max);
for (int i = 0; i < info_count; ++i) {
p_info_arr[i].signature = *(StringName *)&info[i].signature;
p_info_arr[i].call_count = info[i].call_count;
p_info_arr[i].total_time = info[i].total_time;
p_info_arr[i].self_time = info[i].self_time;
godot_string_name_destroy(&info[i].signature);
}
}
#endif
return info_count;
}
int PluginScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
int info_count = 0;
#ifdef DEBUG_ENABLED
if (_desc.profiling_get_frame_data) {
godot_pluginscript_profiling_data *info = (godot_pluginscript_profiling_data *)memalloc(
sizeof(godot_pluginscript_profiling_data) * p_info_max);
info_count = _desc.profiling_get_frame_data(_data, info, p_info_max);
for (int i = 0; i < info_count; ++i) {
p_info_arr[i].signature = *(StringName *)&info[i].signature;
p_info_arr[i].call_count = info[i].call_count;
p_info_arr[i].total_time = info[i].total_time;
p_info_arr[i].self_time = info[i].self_time;
godot_string_name_destroy(&info[i].signature);
}
}
#endif
return info_count;
}
void PluginScriptLanguage::frame() {
#ifdef DEBUG_ENABLED
if (_desc.profiling_frame) {
_desc.profiling_frame(_data);
}
#endif
}
/* DEBUGGER FUNCTIONS */
String PluginScriptLanguage::debug_get_error() const {
if (_desc.debug_get_error) {
godot_string tmp = _desc.debug_get_error(_data);
String ret = *(String *)&tmp;
godot_string_destroy(&tmp);
return ret;
}
return String("Nothing");
}
int PluginScriptLanguage::debug_get_stack_level_count() const {
if (_desc.debug_get_stack_level_count) {
return _desc.debug_get_stack_level_count(_data);
}
return 1;
}
int PluginScriptLanguage::debug_get_stack_level_line(int p_level) const {
if (_desc.debug_get_stack_level_line) {
return _desc.debug_get_stack_level_line(_data, p_level);
}
return 1;
}
String PluginScriptLanguage::debug_get_stack_level_function(int p_level) const {
if (_desc.debug_get_stack_level_function) {
godot_string tmp = _desc.debug_get_stack_level_function(_data, p_level);
String ret = *(String *)&tmp;
godot_string_destroy(&tmp);
return ret;
}
return String("Nothing");
}
String PluginScriptLanguage::debug_get_stack_level_source(int p_level) const {
if (_desc.debug_get_stack_level_source) {
godot_string tmp = _desc.debug_get_stack_level_source(_data, p_level);
String ret = *(String *)&tmp;
godot_string_destroy(&tmp);
return ret;
}
return String("Nothing");
}
void PluginScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
if (_desc.debug_get_stack_level_locals) {
PoolStringArray locals;
Array values;
_desc.debug_get_stack_level_locals(_data, p_level, (godot_pool_string_array *)&locals, (godot_array *)&values, p_max_subitems, p_max_depth);
for (int i = 0; i < locals.size(); i++) {
p_locals->push_back(locals[i]);
}
for (int i = 0; i < values.size(); i++) {
p_values->push_back(values[i]);
}
}
}
void PluginScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
if (_desc.debug_get_stack_level_members) {
PoolStringArray members;
Array values;
_desc.debug_get_stack_level_members(_data, p_level, (godot_pool_string_array *)&members, (godot_array *)&values, p_max_subitems, p_max_depth);
for (int i = 0; i < members.size(); i++) {
p_members->push_back(members[i]);
}
for (int i = 0; i < values.size(); i++) {
p_values->push_back(values[i]);
}
}
}
void PluginScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
if (_desc.debug_get_globals) {
PoolStringArray locals;
Array values;
_desc.debug_get_globals(_data, (godot_pool_string_array *)&locals, (godot_array *)&values, p_max_subitems, p_max_depth);
for (int i = 0; i < locals.size(); i++) {
p_locals->push_back(locals[i]);
}
for (int i = 0; i < values.size(); i++) {
p_values->push_back(values[i]);
}
}
}
String PluginScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
if (_desc.debug_parse_stack_level_expression) {
godot_string tmp = _desc.debug_parse_stack_level_expression(_data, p_level, (godot_string *)&p_expression, p_max_subitems, p_max_depth);
String ret = *(String *)&tmp;
godot_string_destroy(&tmp);
return ret;
}
return String("Nothing");
}
void PluginScriptLanguage::reload_all_scripts() {
// TODO
}
void PluginScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
#ifdef DEBUG_ENABLED
lock();
// TODO
unlock();
#endif
}
void PluginScriptLanguage::lock() {
#ifndef NO_THREADS
if (_lock) {
_lock->lock();
}
#endif
}
void PluginScriptLanguage::unlock() {
#ifndef NO_THREADS
if (_lock) {
_lock->unlock();
}
#endif
}
PluginScriptLanguage::PluginScriptLanguage(const godot_pluginscript_language_desc *desc)
: _desc(*desc) {
_resource_loader = memnew(ResourceFormatLoaderPluginScript(this));
_resource_saver = memnew(ResourceFormatSaverPluginScript(this));
// TODO: totally remove _lock attribute if NO_THREADS is set
#ifdef NO_THREADS
_lock = NULL;
#else
_lock = Mutex::create();
#endif
}
PluginScriptLanguage::~PluginScriptLanguage() {
memdelete(_resource_loader);
memdelete(_resource_saver);
#ifndef NO_THREADS
if (_lock) {
memdelete(_lock);
_lock = NULL;
}
#endif
}

131
modules/gdnative/pluginscript/pluginscript_language.h Normal file
View file

@ -0,0 +1,131 @@
/*************************************************************************/
/* pluginscript_language.h */
/*************************************************************************/
/* 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. */
/*************************************************************************/
#ifndef PLUGINSCRIPT_LANGUAGE_H
#define PLUGINSCRIPT_LANGUAGE_H
// Godot imports
#include "core/io/resource_loader.h"
#include "core/io/resource_saver.h"
#include "core/map.h"
#include "core/script_language.h"
#include "core/self_list.h"
// PluginScript imports
#include "pluginscript_loader.h"
#include <pluginscript/godot_pluginscript.h>
class PluginScript;
class PluginScriptInstance;
class PluginScriptLanguage : public ScriptLanguage {
friend class PluginScript;
friend class PluginScriptInstance;
ResourceFormatLoaderPluginScript *_resource_loader;
ResourceFormatSaverPluginScript *_resource_saver;
const godot_pluginscript_language_desc _desc;
godot_pluginscript_language_data *_data;
Mutex *_lock;
SelfList<PluginScript>::List _script_list;
public:
virtual String get_name() const;
_FORCE_INLINE_ ResourceFormatLoaderPluginScript *get_resource_loader() { return _resource_loader; };
_FORCE_INLINE_ ResourceFormatSaverPluginScript *get_resource_saver() { return _resource_saver; };
/* LANGUAGE FUNCTIONS */
virtual void init();
virtual String get_type() const;
virtual String get_extension() const;
virtual Error execute_file(const String &p_path);
virtual void finish();
/* EDITOR FUNCTIONS */
virtual void get_reserved_words(List<String> *p_words) const;
virtual void get_comment_delimiters(List<String> *p_delimiters) const;
virtual void get_string_delimiters(List<String> *p_delimiters) const;
virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
virtual bool 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 = NULL) const;
virtual Script *create_script() const;
virtual bool has_named_classes() const;
virtual bool can_inherit_from_file() { return true; }
virtual int find_function(const String &p_function, const String &p_code) const;
virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const;
virtual Error complete_code(const String &p_code, const String &p_base_path, Object *p_owner, List<String> *r_options, bool &r_force, String &r_call_hint);
virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const;
virtual void add_global_constant(const StringName &p_variable, const Variant &p_value);
/* MULTITHREAD FUNCTIONS */
//some VMs need to be notified of thread creation/exiting to allocate a stack
// void thread_enter() {}
// void thread_exit() {}
/* DEBUGGER FUNCTIONS */
virtual String debug_get_error() const;
virtual int debug_get_stack_level_count() const;
virtual int debug_get_stack_level_line(int p_level) const;
virtual String debug_get_stack_level_function(int p_level) const;
virtual String debug_get_stack_level_source(int p_level) const;
virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems = -1, int p_max_depth = -1);
virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems = -1, int p_max_depth = -1);
// virtual Vector<StackInfo> debug_get_current_stack_info() { return Vector<StackInfo>(); }
virtual void reload_all_scripts();
virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload);
/* LOADER FUNCTIONS */
virtual void get_recognized_extensions(List<String> *p_extensions) const;
virtual void get_public_functions(List<MethodInfo> *p_functions) const;
virtual void get_public_constants(List<Pair<String, Variant> > *p_constants) const;
virtual void profiling_start();
virtual void profiling_stop();
virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max);
virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max);
virtual void frame();
void lock();
void unlock();
PluginScriptLanguage(const godot_pluginscript_language_desc *desc);
virtual ~PluginScriptLanguage();
};
#endif // PLUGINSCRIPT_LANGUAGE_H

113
modules/gdnative/pluginscript/pluginscript_loader.cpp Normal file
View file

@ -0,0 +1,113 @@
/*************************************************************************/
/* pluginscript_loader.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. */
/*************************************************************************/
// Godot imports
#include "os/file_access.h"
// Pythonscript imports
#include "pluginscript_language.h"
#include "pluginscript_loader.h"
#include "pluginscript_script.h"
ResourceFormatLoaderPluginScript::ResourceFormatLoaderPluginScript(PluginScriptLanguage *language) {
_language = language;
}
RES ResourceFormatLoaderPluginScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
if (r_error)
*r_error = ERR_FILE_CANT_OPEN;
PluginScript *script = memnew(PluginScript);
script->init(_language);
Ref<PluginScript> scriptres(script);
Error err = script->load_source_code(p_path);
ERR_FAIL_COND_V(err != OK, RES());
script->set_path(p_original_path);
script->reload();
if (r_error)
*r_error = OK;
return scriptres;
}
void ResourceFormatLoaderPluginScript::get_recognized_extensions(List<String> *p_extensions) const {
p_extensions->push_back(_language->get_extension());
}
bool ResourceFormatLoaderPluginScript::handles_type(const String &p_type) const {
return p_type == "Script" || p_type == _language->get_type();
}
String ResourceFormatLoaderPluginScript::get_resource_type(const String &p_path) const {
String el = p_path.get_extension().to_lower();
if (el == _language->get_extension())
return _language->get_type();
return "";
}
ResourceFormatSaverPluginScript::ResourceFormatSaverPluginScript(PluginScriptLanguage *language) {
_language = language;
}
Error ResourceFormatSaverPluginScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
Ref<PluginScript> sqscr = p_resource;
ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
String source = sqscr->get_source_code();
Error err;
FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err);
ERR_FAIL_COND_V(err, err);
file->store_string(source);
if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
memdelete(file);
return ERR_CANT_CREATE;
}
file->close();
memdelete(file);
return OK;
}
void ResourceFormatSaverPluginScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
if (Object::cast_to<PluginScript>(*p_resource)) {
p_extensions->push_back(_language->get_extension());
}
}
bool ResourceFormatSaverPluginScript::recognize(const RES &p_resource) const {
return Object::cast_to<PluginScript>(*p_resource) != NULL;
}

62
modules/gdnative/pluginscript/pluginscript_loader.h Normal file
View file

@ -0,0 +1,62 @@
/*************************************************************************/
/* pluginscript_loader.h */
/*************************************************************************/
/* 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. */
/*************************************************************************/
#ifndef PYTHONSCRIPT_PY_LOADER_H
#define PYTHONSCRIPT_PY_LOADER_H
// Godot imports
#include "core/script_language.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
class PluginScriptLanguage;
class ResourceFormatLoaderPluginScript : public ResourceFormatLoader {
PluginScriptLanguage *_language;
public:
ResourceFormatLoaderPluginScript(PluginScriptLanguage *language);
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
virtual void get_recognized_extensions(List<String> *p_extensions) const;
virtual bool handles_type(const String &p_type) const;
virtual String get_resource_type(const String &p_path) const;
};
class ResourceFormatSaverPluginScript : public ResourceFormatSaver {
PluginScriptLanguage *_language;
public:
ResourceFormatSaverPluginScript(PluginScriptLanguage *language);
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
virtual bool recognize(const RES &p_resource) const;
};
#endif // PYTHONSCRIPT_PY_LOADER_H

454
modules/gdnative/pluginscript/pluginscript_script.cpp Normal file
View file

@ -0,0 +1,454 @@
/*************************************************************************/
/* pluginscript_script.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. */
/*************************************************************************/
// Godot imports
#include "core/os/file_access.h"
// PluginScript imports
#include "pluginscript_instance.h"
#include "pluginscript_script.h"
#if DEBUG_ENABLED
#define __ASSERT_SCRIPT_REASON "Cannot retrieve pluginscript class for this script, is you code correct ?"
#define ASSERT_SCRIPT_VALID() \
{ \
ERR_EXPLAIN(__ASSERT_SCRIPT_REASON); \
ERR_FAIL_COND(!can_instance()) \
}
#define ASSERT_SCRIPT_VALID_V(ret) \
{ \
ERR_EXPLAIN(__ASSERT_SCRIPT_REASON); \
ERR_FAIL_COND_V(!can_instance(), ret) \
}
#else
#define ASSERT_SCRIPT_VALID()
#define ASSERT_SCRIPT_VALID_V(ret)
#endif
void PluginScript::_bind_methods() {
}
#ifdef TOOLS_ENABLED
void PluginScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
placeholders.erase(p_placeholder);
}
#endif
bool PluginScript::can_instance() const {
bool can = _valid || (!_tool && !ScriptServer::is_scripting_enabled());
return can;
}
Ref<Script> PluginScript::get_base_script() const {
if (_ref_base_parent.is_valid()) {
return Ref<PluginScript>(_ref_base_parent);
} else {
return Ref<Script>();
}
}
StringName PluginScript::get_instance_base_type() const {
if (_native_parent)
return _native_parent;
if (_ref_base_parent.is_valid())
return _ref_base_parent->get_instance_base_type();
return StringName();
}
void PluginScript::update_exports() {
// TODO
#ifdef TOOLS_ENABLED
#if 0
ASSERT_SCRIPT_VALID();
if (/*changed &&*/ placeholders.size()) { //hm :(
//update placeholders if any
Map<StringName, Variant> propdefvalues;
List<PropertyInfo> propinfos;
const String *props = (const String *)pybind_get_prop_list(_py_exposed_class);
for (int i = 0; props[i] != ""; ++i) {
const String propname = props[i];
pybind_get_prop_default_value(_py_exposed_class, propname.c_str(), (godot_variant *)&propdefvalues[propname]);
pybind_prop_info raw_info;
pybind_get_prop_info(_py_exposed_class, propname.c_str(), &raw_info);
PropertyInfo info;
info.type = (Variant::Type)raw_info.type;
info.name = propname;
info.hint = (PropertyHint)raw_info.hint;
info.hint_string = *(String *)&raw_info.hint_string;
info.usage = raw_info.usage;
propinfos.push_back(info);
}
for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
E->get()->update(propinfos, propdefvalues);
}
}
#endif
#endif
}
// TODO: rename p_this "p_owner" ?
ScriptInstance *PluginScript::instance_create(Object *p_this) {
ASSERT_SCRIPT_VALID_V(NULL);
// TODO check script validity ?
if (!_tool && !ScriptServer::is_scripting_enabled()) {
#ifdef TOOLS_ENABLED
// Instance a fake script for editing the values
PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(get_language(), Ref<Script>(this), p_this));
placeholders.insert(si);
update_exports();
return si;
#else
return NULL;
#endif
}
PluginScript *top = this;
// TODO: can be optimized by storing a PluginScript::_base_parent direct pointer
while (top->_ref_base_parent.is_valid())
top = top->_ref_base_parent.ptr();
if (top->_native_parent) {
if (!ClassDB::is_parent_class(p_this->get_class_name(), top->_native_parent)) {
String msg = "Script inherits from native type '" + String(top->_native_parent) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'";
// TODO: implement PluginscriptLanguage::debug_break_parse
// if (ScriptDebugger::get_singleton()) {
// _language->debug_break_parse(get_path(), 0, msg);
// }
ERR_EXPLAIN(msg);
ERR_FAIL_V(NULL);
}
}
PluginScriptInstance *instance = memnew(PluginScriptInstance());
const bool success = instance->init(this, p_this);
if (success) {
_language->lock();
_instances.insert(instance->get_owner());
_language->unlock();
return instance;
} else {
memdelete(instance);
ERR_FAIL_V(NULL);
}
}
bool PluginScript::instance_has(const Object *p_this) const {
_language->lock();
bool hasit = _instances.has((Object *)p_this);
_language->unlock();
return hasit;
}
bool PluginScript::has_source_code() const {
bool has = _source != "";
return has;
}
String PluginScript::get_source_code() const {
return _source;
}
void PluginScript::set_source_code(const String &p_code) {
if (_source == p_code)
return;
_source = p_code;
}
Error PluginScript::reload(bool p_keep_state) {
_language->lock();
ERR_FAIL_COND_V(!p_keep_state && _instances.size(), ERR_ALREADY_IN_USE);
_language->unlock();
_valid = false;
String basedir = _path;
if (basedir == "")
basedir = get_path();
if (basedir != "")
basedir = basedir.get_base_dir();
if (_data) {
_desc->finish(_data);
}
Error err;
godot_pluginscript_script_manifest manifest = _desc->init(
_language->_data,
(godot_string *)&_path,
(godot_string *)&_source,
(godot_error *)&err);
if (err) {
// TODO: GDscript uses `ScriptDebugger` here to jump into the parsing error
return err;
}
_valid = true;
// Use the manifest to configure this script object
_data = manifest.data;
_name = *(StringName *)&manifest.name;
_tool = manifest.is_tool;
// Base name is either another PluginScript or a regular class accessible
// through ClassDB
StringName *base_name = (StringName *)&manifest.base;
for (SelfList<PluginScript> *e = _language->_script_list.first(); e != NULL; e = e->next()) {
if (e->self()->_name == *base_name) {
// Found you, base is a PluginScript !
_ref_base_parent = Ref<PluginScript>(e->self());
break;
}
}
if (!_ref_base_parent.is_valid()) {
// Base is a native ClassDB
if (!ClassDB::class_exists(*base_name)) {
ERR_EXPLAIN("Unknown script '" + String(_name) + "' parent '" + String(*base_name) + "'.");
ERR_FAIL_V(ERR_PARSE_ERROR);
}
_native_parent = *base_name;
}
Dictionary *members = (Dictionary *)&manifest.member_lines;
for (const Variant *key = members->next(); key != NULL; key = members->next(key)) {
_member_lines[*key] = (*members)[key];
}
Array *methods = (Array *)&manifest.methods;
for (int i = 0; i < methods->size(); ++i) {
Dictionary v = (*methods)[i];
MethodInfo mi = MethodInfo::from_dict(v);
_methods_info[mi.name] = mi;
// rpc_mode is passed as an optional field and is not part of MethodInfo
Variant var = v["rpc_mode"];
if (var == Variant()) {
_methods_rpc_mode[mi.name] = ScriptInstance::RPC_MODE_DISABLED;
} else {
_methods_rpc_mode[mi.name] = ScriptInstance::RPCMode(int(var));
}
}
Array *signals = (Array *)&manifest.signals;
for (int i = 0; i < signals->size(); ++i) {
Variant v = (*signals)[i];
MethodInfo mi = MethodInfo::from_dict(v);
_signals_info[mi.name] = mi;
}
Array *properties = (Array *)&manifest.properties;
for (int i = 0; i < properties->size(); ++i) {
Dictionary v = (*properties)[i];
PropertyInfo pi = PropertyInfo::from_dict(v);
_properties_info[pi.name] = pi;
_properties_default_values[pi.name] = v["default_value"];
// rset_mode is passed as an optional field and is not part of PropertyInfo
Variant var = v["rset_mode"];
if (var == Variant()) {
_methods_rpc_mode[pi.name] = ScriptInstance::RPC_MODE_DISABLED;
} else {
_methods_rpc_mode[pi.name] = ScriptInstance::RPCMode(int(var));
}
}
// Manifest's attributes must be explicitly freed
godot_string_name_destroy(&manifest.name);
godot_string_name_destroy(&manifest.base);
godot_dictionary_destroy(&manifest.member_lines);
godot_array_destroy(&manifest.methods);
godot_array_destroy(&manifest.signals);
godot_array_destroy(&manifest.properties);
#ifdef TOOLS_ENABLED
/*for (Set<PlaceHolderScriptInstance*>::Element *E=placeholders.front();E;E=E->next()) {
_update_placeholder(E->get());
}*/
#endif
return OK;
}
void PluginScript::get_script_method_list(List<MethodInfo> *r_methods) const {
ASSERT_SCRIPT_VALID();
for (Map<StringName, MethodInfo>::Element *e = _methods_info.front(); e != NULL; e = e->next()) {
r_methods->push_back(e->get());
}
}
void PluginScript::get_script_property_list(List<PropertyInfo> *r_properties) const {
ASSERT_SCRIPT_VALID();
for (Map<StringName, PropertyInfo>::Element *e = _properties_info.front(); e != NULL; e = e->next()) {
r_properties->push_back(e->get());
}
}
bool PluginScript::has_method(const StringName &p_method) const {
ASSERT_SCRIPT_VALID_V(false);
return _methods_info.has(p_method);
}
MethodInfo PluginScript::get_method_info(const StringName &p_method) const {
ASSERT_SCRIPT_VALID_V(MethodInfo());
const Map<StringName, MethodInfo>::Element *e = _methods_info.find(p_method);
if (e != NULL) {
return e->get();
} else {
return MethodInfo();
}
}
bool PluginScript::has_property(const StringName &p_method) const {
ASSERT_SCRIPT_VALID_V(false);
return _properties_info.has(p_method);
}
PropertyInfo PluginScript::get_property_info(const StringName &p_property) const {
ASSERT_SCRIPT_VALID_V(PropertyInfo());
const Map<StringName, PropertyInfo>::Element *e = _properties_info.find(p_property);
if (e != NULL) {
return e->get();
} else {
return PropertyInfo();
}
}
bool PluginScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
ASSERT_SCRIPT_VALID_V(false);
#ifdef TOOLS_ENABLED
const Map<StringName, Variant>::Element *e = _properties_default_values.find(p_property);
if (e != NULL) {
r_value = e->get();
return true;
} else {
return false;
}
#endif
return false;
}
String PluginScript::get_node_type() const {
// Even GDscript doesn't know what to put here !
return ""; // ?
}
ScriptLanguage *PluginScript::get_language() const {
return _language;
}
Error PluginScript::load_source_code(const String &p_path) {
PoolVector<uint8_t> sourcef;
Error err;
FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
if (err) {
ERR_FAIL_COND_V(err, err);
}
int len = f->get_len();
sourcef.resize(len + 1);
PoolVector<uint8_t>::Write w = sourcef.write();
int r = f->get_buffer(w.ptr(), len);
f->close();
memdelete(f);
ERR_FAIL_COND_V(r != len, ERR_CANT_OPEN);
w[len] = 0;
String s;
if (s.parse_utf8((const char *)w.ptr())) {
ERR_EXPLAIN("Script '" + p_path + "' contains invalid unicode (utf-8), so it was not loaded. Please ensure that scripts are saved in valid utf-8 unicode.");
ERR_FAIL_V(ERR_INVALID_DATA);
}
_source = s;
#ifdef TOOLS_ENABLED
// source_changed_cache=true;
#endif
_path = p_path;
return OK;
}
bool PluginScript::has_script_signal(const StringName &p_signal) const {
ASSERT_SCRIPT_VALID_V(false);
return _signals_info.has(p_signal);
}
void PluginScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
ASSERT_SCRIPT_VALID();
for (Map<StringName, MethodInfo>::Element *e = _signals_info.front(); e != NULL; e = e->next()) {
r_signals->push_back(e->get());
}
}
int PluginScript::get_member_line(const StringName &p_member) const {
#ifdef TOOLS_ENABLED
if (_member_lines.has(p_member))
return _member_lines[p_member];
else
#endif
return -1;
}
ScriptInstance::RPCMode PluginScript::get_rpc_mode(const StringName &p_method) const {
ASSERT_SCRIPT_VALID_V(ScriptInstance::RPC_MODE_DISABLED);
const Map<StringName, ScriptInstance::RPCMode>::Element *e = _methods_rpc_mode.find(p_method);
if (e != NULL) {
return e->get();
} else {
return ScriptInstance::RPC_MODE_DISABLED;
}
}
ScriptInstance::RPCMode PluginScript::get_rset_mode(const StringName &p_variable) const {
ASSERT_SCRIPT_VALID_V(ScriptInstance::RPC_MODE_DISABLED);
const Map<StringName, ScriptInstance::RPCMode>::Element *e = _variables_rset_mode.find(p_variable);
if (e != NULL) {
return e->get();
} else {
return ScriptInstance::RPC_MODE_DISABLED;
}
}
PluginScript::PluginScript()
: _data(NULL), _tool(false), _valid(false), _script_list(this) {
}
void PluginScript::init(PluginScriptLanguage *language) {
_desc = &language->_desc.script_desc;
_language = language;
#ifdef DEBUG_ENABLED
_language->lock();
_language->_script_list.add(&_script_list);
_language->unlock();
#endif
}
PluginScript::~PluginScript() {
_desc->finish(_data);
#ifdef DEBUG_ENABLED
_language->lock();
_language->_script_list.remove(&_script_list);
_language->unlock();
#endif
}

130
modules/gdnative/pluginscript/pluginscript_script.h Normal file
View file

@ -0,0 +1,130 @@
/*************************************************************************/
/* pluginscript_script.h */
/*************************************************************************/
/* 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. */
/*************************************************************************/
#ifndef PLUGINSCRIPT_SCRIPT_H
#define PLUGINSCRIPT_SCRIPT_H
#include <iostream>
// Godot imports
#include "core/script_language.h"
// PluginScript imports
#include "pluginscript_language.h"
#include <pluginscript/godot_pluginscript.h>
class PyInstance;
class PluginScript : public Script {
GDCLASS(PluginScript, Script);
friend class PluginScriptInstance;
friend class PluginScriptLanguage;
private:
godot_pluginscript_script_data *_data;
const godot_pluginscript_script_desc *_desc;
PluginScriptLanguage *_language;
bool _tool;
bool _valid;
Ref<PluginScript> _ref_base_parent;
StringName _native_parent;
SelfList<PluginScript> _script_list;
Map<StringName, int> _member_lines;
Map<StringName, Variant> _properties_default_values;
Map<StringName, PropertyInfo> _properties_info;
Map<StringName, MethodInfo> _signals_info;
Map<StringName, MethodInfo> _methods_info;
Map<StringName, ScriptInstance::RPCMode> _variables_rset_mode;
Map<StringName, ScriptInstance::RPCMode> _methods_rpc_mode;
Set<Object *> _instances;
//exported members
String _source;
String _path;
StringName _name;
protected:
static void _bind_methods();
#ifdef TOOLS_ENABLED
Set<PlaceHolderScriptInstance *> placeholders;
//void _update_placeholder(PlaceHolderScriptInstance *p_placeholder);
virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
#endif
public:
virtual bool can_instance() const;
virtual Ref<Script> get_base_script() const; //for script inheritance
virtual StringName get_instance_base_type() const; // this may not work in all scripts, will return empty if so
virtual ScriptInstance *instance_create(Object *p_this);
virtual bool instance_has(const Object *p_this) const;
virtual bool has_source_code() const;
virtual String get_source_code() const;
virtual void set_source_code(const String &p_code);
virtual Error reload(bool p_keep_state = false);
// TODO: load_source_code only allow utf-8 file, should handle bytecode as well ?
virtual Error load_source_code(const String &p_path);
virtual bool has_method(const StringName &p_method) const;
virtual MethodInfo get_method_info(const StringName &p_method) const;
bool has_property(const StringName &p_method) const;
PropertyInfo get_property_info(const StringName &p_property) const;
bool is_tool() const { return _tool; }
virtual String get_node_type() const;
virtual ScriptLanguage *get_language() const;
virtual bool has_script_signal(const StringName &p_signal) const;
virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
virtual void update_exports();
virtual void get_script_method_list(List<MethodInfo> *r_methods) const;
virtual void get_script_property_list(List<PropertyInfo> *r_propertieslist) const;
virtual int get_member_line(const StringName &p_member) const;
ScriptInstance::RPCMode get_rpc_mode(const StringName &p_method) const;
ScriptInstance::RPCMode get_rset_mode(const StringName &p_variable) const;
PluginScript();
void init(PluginScriptLanguage *language);
virtual ~PluginScript();
};
#endif // PLUGINSCRIPT_SCRIPT_H

118
modules/gdnative/pluginscript/register_types.cpp Normal file
View file

@ -0,0 +1,118 @@
/*************************************************************************/
/* register_types.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 "register_types.h"
#include "core/project_settings.h"
#include "io/resource_loader.h"
#include "io/resource_saver.h"
#include "os/dir_access.h"
#include "os/os.h"
#include "scene/main/scene_tree.h"
#include "pluginscript_language.h"
#include "pluginscript_script.h"
#include <pluginscript/godot_pluginscript.h>
static List<PluginScriptLanguage *> pluginscript_languages;
static Error _check_language_desc(const godot_pluginscript_language_desc *desc) {
ERR_FAIL_COND_V(!desc->name || desc->name == String(), ERR_BUG);
ERR_FAIL_COND_V(!desc->type || desc->type == String(), ERR_BUG);
ERR_FAIL_COND_V(!desc->extension || desc->extension == String(), ERR_BUG);
ERR_FAIL_COND_V(!desc->recognized_extensions || !desc->recognized_extensions[0], ERR_BUG);
ERR_FAIL_COND_V(!desc->init, ERR_BUG);
ERR_FAIL_COND_V(!desc->finish, ERR_BUG);
// desc->reserved_words is not mandatory
// desc->comment_delimiters is not mandatory
// desc->string_delimiters is not mandatory
// desc->get_template_source_code is not mandatory
// desc->validate is not mandatory
// desc->get_template_source_code is not mandatory
// desc->validate is not mandatory
// desc->find_function is not mandatory
// desc->make_function is not mandatory
// desc->complete_code is not mandatory
// desc->auto_indent_code is not mandatory
// desc->add_global_constant is not mandatory
// desc->debug_get_error is not mandatory
// desc->debug_get_stack_level_count is not mandatory
// desc->debug_get_stack_level_line is not mandatory
// desc->debug_get_stack_level_function is not mandatory
// desc->debug_get_stack_level_source is not mandatory
// desc->debug_get_stack_level_locals is not mandatory
// desc->debug_get_stack_level_members is not mandatory
// desc->debug_get_globals is not mandatory
// desc->debug_parse_stack_level_expression is not mandatory
// desc->profiling_start is not mandatory
// desc->profiling_stop is not mandatory
// desc->profiling_get_accumulated_data is not mandatory
// desc->profiling_get_frame_data is not mandatory
// desc->frame is not mandatory
ERR_FAIL_COND_V(!desc->script_desc.init, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.finish, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.init, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.finish, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.set_prop, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.get_prop, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.call_method, ERR_BUG);
ERR_FAIL_COND_V(!desc->script_desc.instance_desc.notification, ERR_BUG);
// desc->script_desc.instance_desc.refcount_incremented is not mandatory
// desc->script_desc.instance_desc.refcount_decremented is not mandatory
return OK;
}
void GDAPI godot_pluginscript_register_language(const godot_pluginscript_language_desc *language_desc) {
Error ret = _check_language_desc(language_desc);
if (ret) {
ERR_FAIL();
}
PluginScriptLanguage *language = memnew(PluginScriptLanguage(language_desc));
ScriptServer::register_language(language);
ResourceLoader::add_resource_format_loader(language->get_resource_loader());
ResourceSaver::add_resource_format_saver(language->get_resource_saver());
pluginscript_languages.push_back(language);
}
void register_pluginscript_types() {
ClassDB::register_class<PluginScript>();
}
void unregister_pluginscript_types() {
for (List<PluginScriptLanguage *>::Element *e = pluginscript_languages.front(); e; e = e->next()) {
PluginScriptLanguage *language = e->get();
ScriptServer::unregister_language(language);
memdelete(language);
}
}

31
modules/gdnative/pluginscript/register_types.h Normal file
View file

@ -0,0 +1,31 @@
/*************************************************************************/
/* register_types.h */
/*************************************************************************/
/* 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. */
/*************************************************************************/
void register_pluginscript_types();
void unregister_pluginscript_types();

5
modules/gdnative/register_types.cpp
View file

@ -37,6 +37,7 @@
#include "nativearvr/register_types.h"
#include "nativescript/register_types.h"
#include "pluginscript/register_types.h"
#include "core/engine.h"
#include "core/os/os.h"
@ -158,6 +159,7 @@ void register_gdnative_types() {
register_nativearvr_types();
register_nativescript_types();
register_pluginscript_types();
// run singletons
@ -207,8 +209,9 @@ void unregister_gdnative_types() {
}
singleton_gdnatives.clear();
unregister_nativearvr_types();
unregister_pluginscript_types();
unregister_nativescript_types();
unregister_nativearvr_types();
memdelete(GDNativeCallRegistry::singleton);