441 lines
14 KiB
C++
441 lines
14 KiB
C++
/*************************************************************************/
|
|
/* pluginscript_language.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2018 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"
|
|
#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 {
|
|
// We should use _desc.type here, however the returned type is used to
|
|
// query ClassDB which would complain given the type is not registered
|
|
// from his point of view...
|
|
// To solve this we just use a more generic (but present in ClassDB) type.
|
|
return String("PluginScript");
|
|
}
|
|
|
|
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);
|
|
godot_string_destroy(&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;
|
|
}
|
|
|
|
bool PluginScriptLanguage::supports_builtin_mode() const {
|
|
return _desc.supports_builtin_mode;
|
|
}
|
|
|
|
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
|
|
}
|