Sara/viscosity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: removed engine

Browse source
This commit is contained in:
Sara Gerretsen 2026-04-28 14:57:41 +02:00
parent 7fa4aac1c2
commit 49db301d52
13849 changed files with 0 additions and 7324366 deletions
Download patch file Download diff file Expand all files Collapse all files

610
engine/modules/gdscript/editor/gdscript_docgen.cpp
View file

@ -1,610 +0,0 @@
/**************************************************************************/
/* gdscript_docgen.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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 "gdscript_docgen.h"
#include "../gdscript.h"
#include "core/config/project_settings.h"
HashMap<String, String> GDScriptDocGen::singletons;
String GDScriptDocGen::_get_script_name(const String &p_path) {
const HashMap<String, String>::ConstIterator E = singletons.find(p_path);
if (E) {
return E->value;
}
return p_path.trim_prefix("res://").quote();
}
String GDScriptDocGen::_get_class_name(const GDP::ClassNode &p_class) {
const GDP::ClassNode *curr_class = &p_class;
if (!curr_class->identifier) { // All inner classes have an identifier, so this is the outer class.
return _get_script_name(curr_class->fqcn);
}
String full_name = curr_class->identifier->name;
while (curr_class->outer) {
curr_class = curr_class->outer;
if (!curr_class->identifier) { // All inner classes have an identifier, so this is the outer class.
return vformat("%s.%s", _get_script_name(curr_class->fqcn), full_name);
}
full_name = vformat("%s.%s", curr_class->identifier->name, full_name);
}
return full_name;
}
void GDScriptDocGen::_doctype_from_gdtype(const GDType &p_gdtype, String &r_type, String &r_enum, bool p_is_return) {
if (!p_gdtype.is_hard_type()) {
r_type = "Variant";
return;
}
switch (p_gdtype.kind) {
case GDType::BUILTIN:
if (p_gdtype.builtin_type == Variant::NIL) {
r_type = p_is_return ? "void" : "null";
return;
}
if (p_gdtype.builtin_type == Variant::ARRAY && p_gdtype.has_container_element_type(0)) {
_doctype_from_gdtype(p_gdtype.get_container_element_type(0), r_type, r_enum);
if (!r_enum.is_empty()) {
r_type = "int[]";
r_enum += "[]";
return;
}
if (!r_type.is_empty() && r_type != "Variant") {
r_type += "[]";
return;
}
}
if (p_gdtype.builtin_type == Variant::DICTIONARY && p_gdtype.has_container_element_types()) {
String key, value;
_doctype_from_gdtype(p_gdtype.get_container_element_type_or_variant(0), key, r_enum);
_doctype_from_gdtype(p_gdtype.get_container_element_type_or_variant(1), value, r_enum);
if (key != "Variant" || value != "Variant") {
r_type = "Dictionary[" + key + ", " + value + "]";
return;
}
}
r_type = Variant::get_type_name(p_gdtype.builtin_type);
return;
case GDType::NATIVE:
if (p_gdtype.is_meta_type) {
//r_type = GDScriptNativeClass::get_class_static();
r_type = "Object"; // "GDScriptNativeClass" refers to a blank page.
return;
}
r_type = p_gdtype.native_type;
return;
case GDType::SCRIPT:
if (p_gdtype.is_meta_type) {
r_type = p_gdtype.script_type.is_valid() ? p_gdtype.script_type->get_class_name() : Script::get_class_static();
return;
}
if (p_gdtype.script_type.is_valid()) {
if (p_gdtype.script_type->get_global_name() != StringName()) {
r_type = p_gdtype.script_type->get_global_name();
return;
}
if (!p_gdtype.script_type->get_path().is_empty()) {
r_type = _get_script_name(p_gdtype.script_type->get_path());
return;
}
}
if (!p_gdtype.script_path.is_empty()) {
r_type = _get_script_name(p_gdtype.script_path);
return;
}
r_type = "Object";
return;
case GDType::CLASS:
if (p_gdtype.is_meta_type) {
r_type = GDScript::get_class_static();
return;
}
r_type = _get_class_name(*p_gdtype.class_type);
return;
case GDType::ENUM:
if (p_gdtype.is_meta_type) {
r_type = "Dictionary";
return;
}
r_type = "int";
r_enum = String(p_gdtype.native_type).replace("::", ".");
if (r_enum.begins_with("res://")) {
int dot_pos = r_enum.rfind_char('.');
if (dot_pos >= 0) {
r_enum = _get_script_name(r_enum.left(dot_pos)) + r_enum.substr(dot_pos);
} else {
r_enum = _get_script_name(r_enum);
}
}
return;
case GDType::VARIANT:
case GDType::RESOLVING:
case GDType::UNRESOLVED:
r_type = "Variant";
return;
}
}
String GDScriptDocGen::_docvalue_from_variant(const Variant &p_variant, int p_recursion_level) {
constexpr int MAX_RECURSION_LEVEL = 2;
switch (p_variant.get_type()) {
case Variant::STRING:
return String(p_variant).c_escape().quote();
case Variant::OBJECT:
return "<Object>";
case Variant::DICTIONARY: {
const Dictionary dict = p_variant;
String result;
if (dict.is_typed()) {
result += "Dictionary[";
Ref<Script> key_script = dict.get_typed_key_script();
if (key_script.is_valid()) {
if (key_script->get_global_name() != StringName()) {
result += key_script->get_global_name();
} else if (!key_script->get_path().get_file().is_empty()) {
result += key_script->get_path().get_file();
} else {
result += dict.get_typed_key_class_name();
}
} else if (dict.get_typed_key_class_name() != StringName()) {
result += dict.get_typed_key_class_name();
} else if (dict.is_typed_key()) {
result += Variant::get_type_name((Variant::Type)dict.get_typed_key_builtin());
} else {
result += "Variant";
}
result += ", ";
Ref<Script> value_script = dict.get_typed_value_script();
if (value_script.is_valid()) {
if (value_script->get_global_name() != StringName()) {
result += value_script->get_global_name();
} else if (!value_script->get_path().get_file().is_empty()) {
result += value_script->get_path().get_file();
} else {
result += dict.get_typed_value_class_name();
}
} else if (dict.get_typed_value_class_name() != StringName()) {
result += dict.get_typed_value_class_name();
} else if (dict.is_typed_value()) {
result += Variant::get_type_name((Variant::Type)dict.get_typed_value_builtin());
} else {
result += "Variant";
}
result += "](";
}
if (dict.is_empty()) {
result += "{}";
} else if (p_recursion_level > MAX_RECURSION_LEVEL) {
result += "{...}";
} else {
result += "{";
LocalVector<Variant> keys = dict.get_key_list();
keys.sort_custom<StringLikeVariantOrder>();
for (uint32_t i = 0; i < keys.size(); i++) {
const Variant &key = keys[i];
if (i > 0) {
result += ", ";
}
result += _docvalue_from_variant(key, p_recursion_level + 1) + ": " + _docvalue_from_variant(dict[key], p_recursion_level + 1);
}
result += "}";
}
if (dict.is_typed()) {
result += ")";
}
return result;
} break;
case Variant::ARRAY: {
const Array array = p_variant;
String result;
if (array.is_typed()) {
result += "Array[";
Ref<Script> script = array.get_typed_script();
if (script.is_valid()) {
if (script->get_global_name() != StringName()) {
result += script->get_global_name();
} else if (!script->get_path().get_file().is_empty()) {
result += script->get_path().get_file();
} else {
result += array.get_typed_class_name();
}
} else if (array.get_typed_class_name() != StringName()) {
result += array.get_typed_class_name();
} else {
result += Variant::get_type_name((Variant::Type)array.get_typed_builtin());
}
result += "](";
}
if (array.is_empty()) {
result += "[]";
} else if (p_recursion_level > MAX_RECURSION_LEVEL) {
result += "[...]";
} else {
result += "[";
for (int i = 0; i < array.size(); i++) {
if (i > 0) {
result += ", ";
}
result += _docvalue_from_variant(array[i], p_recursion_level + 1);
}
result += "]";
}
if (array.is_typed()) {
result += ")";
}
return result;
} break;
default:
return p_variant.get_construct_string();
}
}
String GDScriptDocGen::docvalue_from_expression(const GDP::ExpressionNode *p_expression) {
ERR_FAIL_NULL_V(p_expression, String());
if (p_expression->is_constant) {
return _docvalue_from_variant(p_expression->reduced_value);
}
switch (p_expression->type) {
case GDP::Node::ARRAY: {
const GDP::ArrayNode *array = static_cast<const GDP::ArrayNode *>(p_expression);
return array->elements.is_empty() ? "[]" : "[...]";
} break;
case GDP::Node::CALL: {
const GDP::CallNode *call = static_cast<const GDP::CallNode *>(p_expression);
if (call->get_callee_type() == GDP::Node::IDENTIFIER) {
return call->function_name.operator String() + (call->arguments.is_empty() ? "()" : "(...)");
}
} break;
case GDP::Node::DICTIONARY: {
const GDP::DictionaryNode *dict = static_cast<const GDP::DictionaryNode *>(p_expression);
return dict->elements.is_empty() ? "{}" : "{...}";
} break;
case GDP::Node::IDENTIFIER: {
const GDP::IdentifierNode *id = static_cast<const GDP::IdentifierNode *>(p_expression);
return id->name;
} break;
default: {
// Nothing to do.
} break;
}
return "<unknown>";
}
void GDScriptDocGen::_generate_docs(GDScript *p_script, const GDP::ClassNode *p_class) {
p_script->_clear_doc();
DocData::ClassDoc &doc = p_script->doc;
doc.is_script_doc = true;
if (p_script->local_name == StringName()) {
// This is an outer unnamed class.
doc.name = _get_script_name(p_script->get_script_path());
} else {
// This is an inner or global outer class.
doc.name = p_script->local_name;
if (p_script->_owner) {
doc.name = p_script->_owner->doc.name + "." + doc.name;
}
}
doc.script_path = p_script->get_script_path();
if (p_script->base.is_valid() && p_script->base->is_valid()) {
if (!p_script->base->doc.name.is_empty()) {
doc.inherits = p_script->base->doc.name;
} else {
doc.inherits = p_script->base->get_instance_base_type();
}
} else if (p_script->native.is_valid()) {
doc.inherits = p_script->native->get_name();
}
doc.brief_description = p_class->doc_data.brief;
doc.description = p_class->doc_data.description;
for (const Pair<String, String> &p : p_class->doc_data.tutorials) {
DocData::TutorialDoc td;
td.title = p.first;
td.link = p.second;
doc.tutorials.append(td);
}
doc.is_deprecated = p_class->doc_data.is_deprecated;
doc.deprecated_message = p_class->doc_data.deprecated_message;
doc.is_experimental = p_class->doc_data.is_experimental;
doc.experimental_message = p_class->doc_data.experimental_message;
for (const GDP::ClassNode::Member &member : p_class->members) {
switch (member.type) {
case GDP::ClassNode::Member::CLASS: {
const GDP::ClassNode *inner_class = member.m_class;
const StringName &class_name = inner_class->identifier->name;
p_script->member_lines[class_name] = inner_class->start_line;
// Recursively generate inner class docs.
// Needs inner GDScripts to exist: previously generated in GDScriptCompiler::make_scripts().
GDScriptDocGen::_generate_docs(*p_script->subclasses[class_name], inner_class);
} break;
case GDP::ClassNode::Member::CONSTANT: {
const GDP::ConstantNode *m_const = member.constant;
const StringName &const_name = member.constant->identifier->name;
p_script->member_lines[const_name] = m_const->start_line;
DocData::ConstantDoc const_doc;
const_doc.name = const_name;
const_doc.value = _docvalue_from_variant(m_const->initializer->reduced_value);
const_doc.is_value_valid = true;
_doctype_from_gdtype(m_const->get_datatype(), const_doc.type, const_doc.enumeration);
const_doc.description = m_const->doc_data.description;
const_doc.is_deprecated = m_const->doc_data.is_deprecated;
const_doc.deprecated_message = m_const->doc_data.deprecated_message;
const_doc.is_experimental = m_const->doc_data.is_experimental;
const_doc.experimental_message = m_const->doc_data.experimental_message;
doc.constants.push_back(const_doc);
} break;
case GDP::ClassNode::Member::FUNCTION: {
const GDP::FunctionNode *m_func = member.function;
const StringName &func_name = m_func->identifier->name;
p_script->member_lines[func_name] = m_func->start_line;
DocData::MethodDoc method_doc;
method_doc.name = func_name;
method_doc.description = m_func->doc_data.description;
method_doc.is_deprecated = m_func->doc_data.is_deprecated;
method_doc.deprecated_message = m_func->doc_data.deprecated_message;
method_doc.is_experimental = m_func->doc_data.is_experimental;
method_doc.experimental_message = m_func->doc_data.experimental_message;
if (m_func->is_vararg()) {
if (!method_doc.qualifiers.is_empty()) {
method_doc.qualifiers += " ";
}
method_doc.qualifiers += "vararg";
method_doc.rest_argument.name = m_func->rest_parameter->identifier->name;
_doctype_from_gdtype(m_func->rest_parameter->get_datatype(), method_doc.rest_argument.type, method_doc.rest_argument.enumeration);
}
if (m_func->is_abstract) {
if (!method_doc.qualifiers.is_empty()) {
method_doc.qualifiers += " ";
}
method_doc.qualifiers += "abstract";
}
if (m_func->is_static) {
if (!method_doc.qualifiers.is_empty()) {
method_doc.qualifiers += " ";
}
method_doc.qualifiers += "static";
}
if (func_name == "_init") {
method_doc.return_type = "void";
} else if (m_func->return_type) {
// `m_func->return_type->get_datatype()` is a metatype.
_doctype_from_gdtype(m_func->get_datatype(), method_doc.return_type, method_doc.return_enum, true);
} else if (!m_func->body->has_return) {
// If no `return` statement, then return type is `void`, not `Variant`.
method_doc.return_type = "void";
} else {
method_doc.return_type = "Variant";
}
for (const GDP::ParameterNode *p : m_func->parameters) {
DocData::ArgumentDoc arg_doc;
arg_doc.name = p->identifier->name;
_doctype_from_gdtype(p->get_datatype(), arg_doc.type, arg_doc.enumeration);
if (p->initializer != nullptr) {
arg_doc.default_value = docvalue_from_expression(p->initializer);
}
method_doc.arguments.push_back(arg_doc);
}
doc.methods.push_back(method_doc);
} break;
case GDP::ClassNode::Member::SIGNAL: {
const GDP::SignalNode *m_signal = member.signal;
const StringName &signal_name = m_signal->identifier->name;
p_script->member_lines[signal_name] = m_signal->start_line;
DocData::MethodDoc signal_doc;
signal_doc.name = signal_name;
signal_doc.description = m_signal->doc_data.description;
signal_doc.is_deprecated = m_signal->doc_data.is_deprecated;
signal_doc.deprecated_message = m_signal->doc_data.deprecated_message;
signal_doc.is_experimental = m_signal->doc_data.is_experimental;
signal_doc.experimental_message = m_signal->doc_data.experimental_message;
for (const GDP::ParameterNode *p : m_signal->parameters) {
DocData::ArgumentDoc arg_doc;
arg_doc.name = p->identifier->name;
_doctype_from_gdtype(p->get_datatype(), arg_doc.type, arg_doc.enumeration);
signal_doc.arguments.push_back(arg_doc);
}
doc.signals.push_back(signal_doc);
} break;
case GDP::ClassNode::Member::VARIABLE: {
const GDP::VariableNode *m_var = member.variable;
const StringName &var_name = m_var->identifier->name;
p_script->member_lines[var_name] = m_var->start_line;
DocData::PropertyDoc prop_doc;
prop_doc.name = var_name;
prop_doc.description = m_var->doc_data.description;
prop_doc.is_deprecated = m_var->doc_data.is_deprecated;
prop_doc.deprecated_message = m_var->doc_data.deprecated_message;
prop_doc.is_experimental = m_var->doc_data.is_experimental;
prop_doc.experimental_message = m_var->doc_data.experimental_message;
_doctype_from_gdtype(m_var->get_datatype(), prop_doc.type, prop_doc.enumeration);
switch (m_var->property) {
case GDP::VariableNode::PROP_NONE:
break;
case GDP::VariableNode::PROP_INLINE:
if (m_var->setter != nullptr) {
prop_doc.setter = m_var->setter->identifier->name;
}
if (m_var->getter != nullptr) {
prop_doc.getter = m_var->getter->identifier->name;
}
break;
case GDP::VariableNode::PROP_SETGET:
if (m_var->setter_pointer != nullptr) {
prop_doc.setter = m_var->setter_pointer->name;
}
if (m_var->getter_pointer != nullptr) {
prop_doc.getter = m_var->getter_pointer->name;
}
break;
}
if (m_var->initializer != nullptr) {
prop_doc.default_value = docvalue_from_expression(m_var->initializer);
}
prop_doc.overridden = false;
doc.properties.push_back(prop_doc);
} break;
case GDP::ClassNode::Member::ENUM: {
const GDP::EnumNode *m_enum = member.m_enum;
StringName name = m_enum->identifier->name;
p_script->member_lines[name] = m_enum->start_line;
DocData::EnumDoc enum_doc;
enum_doc.description = m_enum->doc_data.description;
enum_doc.is_deprecated = m_enum->doc_data.is_deprecated;
enum_doc.deprecated_message = m_enum->doc_data.deprecated_message;
enum_doc.is_experimental = m_enum->doc_data.is_experimental;
enum_doc.experimental_message = m_enum->doc_data.experimental_message;
doc.enums[name] = enum_doc;
for (const GDP::EnumNode::Value &val : m_enum->values) {
DocData::ConstantDoc const_doc;
const_doc.name = val.identifier->name;
const_doc.value = _docvalue_from_variant(val.value);
const_doc.is_value_valid = true;
const_doc.type = "int";
const_doc.enumeration = name;
const_doc.description = val.doc_data.description;
const_doc.is_deprecated = val.doc_data.is_deprecated;
const_doc.deprecated_message = val.doc_data.deprecated_message;
const_doc.is_experimental = val.doc_data.is_experimental;
const_doc.experimental_message = val.doc_data.experimental_message;
doc.constants.push_back(const_doc);
}
} break;
case GDP::ClassNode::Member::ENUM_VALUE: {
const GDP::EnumNode::Value &m_enum_val = member.enum_value;
const StringName &name = m_enum_val.identifier->name;
p_script->member_lines[name] = m_enum_val.identifier->start_line;
DocData::ConstantDoc const_doc;
const_doc.name = name;
const_doc.value = _docvalue_from_variant(m_enum_val.value);
const_doc.is_value_valid = true;
const_doc.type = "int";
const_doc.enumeration = "@unnamed_enums";
const_doc.description = m_enum_val.doc_data.description;
const_doc.is_deprecated = m_enum_val.doc_data.is_deprecated;
const_doc.deprecated_message = m_enum_val.doc_data.deprecated_message;
const_doc.is_experimental = m_enum_val.doc_data.is_experimental;
const_doc.experimental_message = m_enum_val.doc_data.experimental_message;
doc.constants.push_back(const_doc);
} break;
default:
break;
}
}
// Add doc to the outer-most class.
p_script->_add_doc(doc);
}
void GDScriptDocGen::generate_docs(GDScript *p_script, const GDP::ClassNode *p_class) {
for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : ProjectSettings::get_singleton()->get_autoload_list()) {
if (E.value.is_singleton) {
singletons[E.value.path] = E.key;
}
}
_generate_docs(p_script, p_class);
singletons.clear();
}
// This method is needed for the editor, since during autocompletion the script is not compiled, only analyzed.
void GDScriptDocGen::doctype_from_gdtype(const GDType &p_gdtype, String &r_type, String &r_enum, bool p_is_return) {
for (const KeyValue<StringName, ProjectSettings::AutoloadInfo> &E : ProjectSettings::get_singleton()->get_autoload_list()) {
if (E.value.is_singleton) {
singletons[E.value.path] = E.key;
}
}
_doctype_from_gdtype(p_gdtype, r_type, r_enum, p_is_return);
singletons.clear();
}

53
engine/modules/gdscript/editor/gdscript_docgen.h
View file

@ -1,53 +0,0 @@
/**************************************************************************/
/* gdscript_docgen.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#pragma once
#include "../gdscript_parser.h"
#include "core/doc_data.h"
class GDScriptDocGen {
using GDP = GDScriptParser;
using GDType = GDP::DataType;
static HashMap<String, String> singletons; // Script path to singleton name.
static String _get_script_name(const String &p_path);
static String _get_class_name(const GDP::ClassNode &p_class);
static void _doctype_from_gdtype(const GDType &p_gdtype, String &r_type, String &r_enum, bool p_is_return = false);
static String _docvalue_from_variant(const Variant &p_variant, int p_recursion_level = 1);
static void _generate_docs(GDScript *p_script, const GDP::ClassNode *p_class);
public:
static void generate_docs(GDScript *p_script, const GDP::ClassNode *p_class);
static void doctype_from_gdtype(const GDType &p_gdtype, String &r_type, String &r_enum, bool p_is_return = false);
static String docvalue_from_expression(const GDP::ExpressionNode *p_expression);
};

1017
engine/modules/gdscript/editor/gdscript_highlighter.cpp
View file

File diff suppressed because it is too large Load diff

118
engine/modules/gdscript/editor/gdscript_highlighter.h
View file

@ -1,118 +0,0 @@
/**************************************************************************/
/* gdscript_highlighter.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#pragma once
#include "editor/script/script_editor_plugin.h"
class GDScriptSyntaxHighlighter : public EditorSyntaxHighlighter {
GDCLASS(GDScriptSyntaxHighlighter, EditorSyntaxHighlighter)
private:
struct ColorRegion {
enum Type {
TYPE_NONE,
TYPE_STRING, // `"` and `'`, optional prefix `&`, `^`, or `r`.
TYPE_MULTILINE_STRING, // `"""` and `'''`, optional prefix `r`.
TYPE_COMMENT, // `#` and `##`.
TYPE_CODE_REGION, // `#region` and `#endregion`.
};
Type type = TYPE_NONE;
Color color;
String start_key;
String end_key;
bool line_only = false;
bool r_prefix = false;
bool is_string = false; // `TYPE_STRING` or `TYPE_MULTILINE_STRING`.
bool is_comment = false; // `TYPE_COMMENT` or `TYPE_CODE_REGION`.
};
Vector<ColorRegion> color_regions;
HashMap<int, int> color_region_cache;
HashMap<StringName, Color> class_names;
HashMap<StringName, Color> reserved_keywords;
HashMap<StringName, Color> member_keywords;
HashSet<StringName> global_functions;
enum Type {
NONE,
REGION,
NODE_PATH,
NODE_REF,
ANNOTATION,
STRING_NAME,
SYMBOL,
NUMBER,
FUNCTION,
SIGNAL,
KEYWORD,
MEMBER,
IDENTIFIER,
TYPE,
};
// Colors.
Color font_color;
Color symbol_color;
Color function_color;
Color global_function_color;
Color function_definition_color;
Color built_in_type_color;
Color number_color;
Color member_variable_color;
Color string_color;
Color placeholder_color;
Color node_path_color;
Color node_ref_color;
Color annotation_color;
Color string_name_color;
Color type_color;
enum CommentMarkerLevel {
COMMENT_MARKER_CRITICAL,
COMMENT_MARKER_WARNING,
COMMENT_MARKER_NOTICE,
COMMENT_MARKER_MAX,
};
Color comment_marker_colors[COMMENT_MARKER_MAX];
HashMap<String, CommentMarkerLevel> comment_markers;
void add_color_region(ColorRegion::Type p_type, const String &p_start_key, const String &p_end_key, const Color &p_color, bool p_line_only = false, bool p_r_prefix = false);
public:
virtual void _update_cache() override;
virtual Dictionary _get_line_syntax_highlighting_impl(int p_line) override;
virtual String _get_name() const override;
virtual PackedStringArray _get_supported_languages() const override;
virtual Ref<EditorSyntaxHighlighter> _create() const override;
};

459
engine/modules/gdscript/editor/gdscript_translation_parser_plugin.cpp
View file

@ -1,459 +0,0 @@
/**************************************************************************/
/* gdscript_translation_parser_plugin.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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 "gdscript_translation_parser_plugin.h"
#include "../gdscript.h"
#include "../gdscript_analyzer.h"
#include "core/io/resource_loader.h"
void GDScriptEditorTranslationParserPlugin::get_recognized_extensions(List<String> *r_extensions) const {
GDScriptLanguage::get_singleton()->get_recognized_extensions(r_extensions);
}
Error GDScriptEditorTranslationParserPlugin::parse_file(const String &p_path, Vector<Vector<String>> *r_translations) {
// Extract all translatable strings using the parsed tree from GDScriptParser.
// The strategy is to find all ExpressionNode and AssignmentNode from the tree and extract strings if relevant, i.e
// Search strings in ExpressionNode -> CallNode -> tr(), set_text(), set_placeholder() etc.
// Search strings in AssignmentNode -> text = "__", tooltip_text = "__" etc.
Error err;
Ref<Resource> loaded_res = ResourceLoader::load(p_path, "", ResourceFormatLoader::CACHE_MODE_REUSE, &err);
ERR_FAIL_COND_V_MSG(err, err, "Failed to load " + p_path);
translations = r_translations;
Ref<GDScript> gdscript = loaded_res;
String source_code = gdscript->get_source_code();
GDScriptParser parser;
err = parser.parse(source_code, p_path, false);
ERR_FAIL_COND_V_MSG(err, err, "Failed to parse GDScript with GDScriptParser.");
GDScriptAnalyzer analyzer(&parser);
err = analyzer.analyze();
ERR_FAIL_COND_V_MSG(err, err, "Failed to analyze GDScript with GDScriptAnalyzer.");
comment_data = &parser.comment_data;
// Traverse through the parsed tree from GDScriptParser.
GDScriptParser::ClassNode *c = parser.get_tree();
_traverse_class(c);
comment_data = nullptr;
return OK;
}
bool GDScriptEditorTranslationParserPlugin::_is_constant_string(const GDScriptParser::ExpressionNode *p_expression) {
ERR_FAIL_NULL_V(p_expression, false);
return p_expression->is_constant && p_expression->reduced_value.is_string();
}
String GDScriptEditorTranslationParserPlugin::_parse_comment(int p_line, bool &r_skip) const {
// Parse inline comment.
if (comment_data->has(p_line)) {
const String stripped_comment = comment_data->get(p_line).comment.trim_prefix("#").strip_edges();
if (stripped_comment.begins_with("TRANSLATORS:")) {
return stripped_comment.trim_prefix("TRANSLATORS:").strip_edges(true, false);
}
if (stripped_comment == "NO_TRANSLATE" || stripped_comment.begins_with("NO_TRANSLATE:")) {
r_skip = true;
return String();
}
}
// Parse multiline comment.
String multiline_comment;
for (int line = p_line - 1; comment_data->has(line) && comment_data->get(line).new_line; line--) {
const String stripped_comment = comment_data->get(line).comment.trim_prefix("#").strip_edges();
if (stripped_comment.is_empty()) {
continue;
}
if (multiline_comment.is_empty()) {
multiline_comment = stripped_comment;
} else {
multiline_comment = stripped_comment + "\n" + multiline_comment;
}
if (stripped_comment.begins_with("TRANSLATORS:")) {
return multiline_comment.trim_prefix("TRANSLATORS:").strip_edges(true, false);
}
if (stripped_comment == "NO_TRANSLATE" || stripped_comment.begins_with("NO_TRANSLATE:")) {
r_skip = true;
return String();
}
}
return String();
}
void GDScriptEditorTranslationParserPlugin::_add_id(const String &p_id, int p_line) {
bool skip = false;
const String comment = _parse_comment(p_line, skip);
if (skip) {
return;
}
translations->push_back({ p_id, String(), String(), comment, itos(p_line) });
}
void GDScriptEditorTranslationParserPlugin::_add_id_ctx_plural(const Vector<String> &p_id_ctx_plural, int p_line) {
bool skip = false;
const String comment = _parse_comment(p_line, skip);
if (skip) {
return;
}
translations->push_back({ p_id_ctx_plural[0], p_id_ctx_plural[1], p_id_ctx_plural[2], comment, itos(p_line) });
}
void GDScriptEditorTranslationParserPlugin::_traverse_class(const GDScriptParser::ClassNode *p_class) {
for (int i = 0; i < p_class->members.size(); i++) {
const GDScriptParser::ClassNode::Member &m = p_class->members[i];
// Other member types can't contain translatable strings.
switch (m.type) {
case GDScriptParser::ClassNode::Member::CLASS:
_traverse_class(m.m_class);
break;
case GDScriptParser::ClassNode::Member::FUNCTION:
_traverse_function(m.function);
break;
case GDScriptParser::ClassNode::Member::VARIABLE:
_assess_expression(m.variable->initializer);
if (m.variable->property == GDScriptParser::VariableNode::PROP_INLINE) {
_traverse_function(m.variable->setter);
_traverse_function(m.variable->getter);
}
break;
default:
break;
}
}
}
void GDScriptEditorTranslationParserPlugin::_traverse_function(const GDScriptParser::FunctionNode *p_func) {
if (!p_func) {
return;
}
for (int i = 0; i < p_func->parameters.size(); i++) {
_assess_expression(p_func->parameters[i]->initializer);
}
_traverse_block(p_func->body);
}
void GDScriptEditorTranslationParserPlugin::_traverse_block(const GDScriptParser::SuiteNode *p_suite) {
if (!p_suite) {
return;
}
const Vector<GDScriptParser::Node *> &statements = p_suite->statements;
for (int i = 0; i < statements.size(); i++) {
const GDScriptParser::Node *statement = statements[i];
// BREAK, BREAKPOINT, CONSTANT, CONTINUE, and PASS are skipped because they can't contain translatable strings.
switch (statement->type) {
case GDScriptParser::Node::ASSERT: {
const GDScriptParser::AssertNode *assert_node = static_cast<const GDScriptParser::AssertNode *>(statement);
_assess_expression(assert_node->condition);
_assess_expression(assert_node->message);
} break;
case GDScriptParser::Node::ASSIGNMENT: {
_assess_assignment(static_cast<const GDScriptParser::AssignmentNode *>(statement));
} break;
case GDScriptParser::Node::FOR: {
const GDScriptParser::ForNode *for_node = static_cast<const GDScriptParser::ForNode *>(statement);
_assess_expression(for_node->list);
_traverse_block(for_node->loop);
} break;
case GDScriptParser::Node::IF: {
const GDScriptParser::IfNode *if_node = static_cast<const GDScriptParser::IfNode *>(statement);
_assess_expression(if_node->condition);
_traverse_block(if_node->true_block);
_traverse_block(if_node->false_block);
} break;
case GDScriptParser::Node::MATCH: {
const GDScriptParser::MatchNode *match_node = static_cast<const GDScriptParser::MatchNode *>(statement);
_assess_expression(match_node->test);
for (int j = 0; j < match_node->branches.size(); j++) {
_traverse_block(match_node->branches[j]->guard_body);
_traverse_block(match_node->branches[j]->block);
}
} break;
case GDScriptParser::Node::RETURN: {
_assess_expression(static_cast<const GDScriptParser::ReturnNode *>(statement)->return_value);
} break;
case GDScriptParser::Node::VARIABLE: {
_assess_expression(static_cast<const GDScriptParser::VariableNode *>(statement)->initializer);
} break;
case GDScriptParser::Node::WHILE: {
const GDScriptParser::WhileNode *while_node = static_cast<const GDScriptParser::WhileNode *>(statement);
_assess_expression(while_node->condition);
_traverse_block(while_node->loop);
} break;
default: {
if (statement->is_expression()) {
_assess_expression(static_cast<const GDScriptParser::ExpressionNode *>(statement));
}
} break;
}
}
}
void GDScriptEditorTranslationParserPlugin::_assess_expression(const GDScriptParser::ExpressionNode *p_expression) {
// Explore all ExpressionNodes to find CallNodes which contain translation strings, such as tr(), set_text() etc.
// tr() can be embedded quite deep within multiple ExpressionNodes so need to dig down to search through all ExpressionNodes.
if (!p_expression) {
return;
}
// GET_NODE, IDENTIFIER, LITERAL, PRELOAD, SELF, and TYPE are skipped because they can't contain translatable strings.
switch (p_expression->type) {
case GDScriptParser::Node::ARRAY: {
const GDScriptParser::ArrayNode *array_node = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
for (int i = 0; i < array_node->elements.size(); i++) {
_assess_expression(array_node->elements[i]);
}
} break;
case GDScriptParser::Node::ASSIGNMENT: {
_assess_assignment(static_cast<const GDScriptParser::AssignmentNode *>(p_expression));
} break;
case GDScriptParser::Node::AWAIT: {
_assess_expression(static_cast<const GDScriptParser::AwaitNode *>(p_expression)->to_await);
} break;
case GDScriptParser::Node::BINARY_OPERATOR: {
const GDScriptParser::BinaryOpNode *binary_op_node = static_cast<const GDScriptParser::BinaryOpNode *>(p_expression);
_assess_expression(binary_op_node->left_operand);
_assess_expression(binary_op_node->right_operand);
} break;
case GDScriptParser::Node::CALL: {
_assess_call(static_cast<const GDScriptParser::CallNode *>(p_expression));
} break;
case GDScriptParser::Node::CAST: {
_assess_expression(static_cast<const GDScriptParser::CastNode *>(p_expression)->operand);
} break;
case GDScriptParser::Node::DICTIONARY: {
const GDScriptParser::DictionaryNode *dict_node = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
for (int i = 0; i < dict_node->elements.size(); i++) {
_assess_expression(dict_node->elements[i].key);
_assess_expression(dict_node->elements[i].value);
}
} break;
case GDScriptParser::Node::LAMBDA: {
_traverse_function(static_cast<const GDScriptParser::LambdaNode *>(p_expression)->function);
} break;
case GDScriptParser::Node::SUBSCRIPT: {
const GDScriptParser::SubscriptNode *subscript_node = static_cast<const GDScriptParser::SubscriptNode *>(p_expression);
_assess_expression(subscript_node->base);
if (!subscript_node->is_attribute) {
_assess_expression(subscript_node->index);
}
} break;
case GDScriptParser::Node::TERNARY_OPERATOR: {
const GDScriptParser::TernaryOpNode *ternary_op_node = static_cast<const GDScriptParser::TernaryOpNode *>(p_expression);
_assess_expression(ternary_op_node->condition);
_assess_expression(ternary_op_node->true_expr);
_assess_expression(ternary_op_node->false_expr);
} break;
case GDScriptParser::Node::TYPE_TEST: {
_assess_expression(static_cast<const GDScriptParser::TypeTestNode *>(p_expression)->operand);
} break;
case GDScriptParser::Node::UNARY_OPERATOR: {
_assess_expression(static_cast<const GDScriptParser::UnaryOpNode *>(p_expression)->operand);
} break;
default: {
} break;
}
}
void GDScriptEditorTranslationParserPlugin::_assess_assignment(const GDScriptParser::AssignmentNode *p_assignment) {
_assess_expression(p_assignment->assignee);
_assess_expression(p_assignment->assigned_value);
// Extract the translatable strings coming from assignments. For example, get_node("Label").text = "____"
StringName assignee_name;
if (p_assignment->assignee->type == GDScriptParser::Node::IDENTIFIER) {
assignee_name = static_cast<const GDScriptParser::IdentifierNode *>(p_assignment->assignee)->name;
} else if (p_assignment->assignee->type == GDScriptParser::Node::SUBSCRIPT) {
const GDScriptParser::SubscriptNode *subscript = static_cast<const GDScriptParser::SubscriptNode *>(p_assignment->assignee);
if (subscript->is_attribute && subscript->attribute) {
assignee_name = subscript->attribute->name;
} else if (subscript->index && _is_constant_string(subscript->index)) {
assignee_name = subscript->index->reduced_value;
}
}
if (assignee_name != StringName() && assignment_patterns.has(assignee_name) && _is_constant_string(p_assignment->assigned_value)) {
// If the assignment is towards one of the extract patterns (text, tooltip_text etc.), and the value is a constant string, we collect the string.
_add_id(p_assignment->assigned_value->reduced_value, p_assignment->assigned_value->start_line);
} else if (assignee_name == fd_filters) {
// Extract from `get_node("FileDialog").filters = <filter array>`.
_extract_fd_filter_array(p_assignment->assigned_value);
}
}
void GDScriptEditorTranslationParserPlugin::_assess_call(const GDScriptParser::CallNode *p_call) {
_assess_expression(p_call->callee);
for (int i = 0; i < p_call->arguments.size(); i++) {
_assess_expression(p_call->arguments[i]);
}
// Extract the translatable strings coming from function calls. For example:
// tr("___"), get_node("Label").set_text("____"), get_node("LineEdit").set_placeholder("____").
StringName function_name = p_call->function_name;
// Variables for extracting tr() and tr_n().
Vector<String> id_ctx_plural;
id_ctx_plural.resize(3);
bool extract_id_ctx_plural = true;
if (function_name == tr_func || function_name == atr_func) {
// Extract from `tr(id, ctx)` or `atr(id, ctx)`.
for (int i = 0; i < p_call->arguments.size(); i++) {
if (_is_constant_string(p_call->arguments[i])) {
id_ctx_plural.write[i] = p_call->arguments[i]->reduced_value;
} else {
// Avoid adding something like tr("Flying dragon", var_context_level_1). We want to extract both id and context together.
extract_id_ctx_plural = false;
}
}
if (extract_id_ctx_plural) {
_add_id_ctx_plural(id_ctx_plural, p_call->start_line);
}
} else if (function_name == trn_func || function_name == atrn_func) {
// Extract from `tr_n(id, plural, n, ctx)` or `atr_n(id, plural, n, ctx)`.
Vector<int> indices;
indices.push_back(0);
indices.push_back(3);
indices.push_back(1);
for (int i = 0; i < indices.size(); i++) {
if (indices[i] >= p_call->arguments.size()) {
continue;
}
if (_is_constant_string(p_call->arguments[indices[i]])) {
id_ctx_plural.write[i] = p_call->arguments[indices[i]]->reduced_value;
} else {
extract_id_ctx_plural = false;
}
}
if (extract_id_ctx_plural) {
_add_id_ctx_plural(id_ctx_plural, p_call->start_line);
}
} else if (first_arg_patterns.has(function_name)) {
if (!p_call->arguments.is_empty() && _is_constant_string(p_call->arguments[0])) {
_add_id(p_call->arguments[0]->reduced_value, p_call->arguments[0]->start_line);
}
} else if (second_arg_patterns.has(function_name)) {
if (p_call->arguments.size() > 1 && _is_constant_string(p_call->arguments[1])) {
_add_id(p_call->arguments[1]->reduced_value, p_call->arguments[1]->start_line);
}
} else if (function_name == fd_add_filter) {
if (p_call->arguments.size() == 1) {
// The first parameter may contain a description, like `"*.jpg; JPEG Images"`.
_extract_fd_filter_string(p_call->arguments[0], p_call->arguments[0]->start_line);
} else if (p_call->arguments.size() >= 2) {
// The second optional parameter can be a description.
if (_is_constant_string(p_call->arguments[1])) {
_add_id(p_call->arguments[1]->reduced_value, p_call->arguments[1]->start_line);
}
}
} else if (function_name == fd_set_filter) {
// Extract from `get_node("FileDialog").set_filters(<filter array>)`.
if (!p_call->arguments.is_empty()) {
_extract_fd_filter_array(p_call->arguments[0]);
}
}
}
void GDScriptEditorTranslationParserPlugin::_extract_fd_filter_string(const GDScriptParser::ExpressionNode *p_expression, int p_line) {
// Extract the description from `"filter; Description"` format.
// The description part is optional, so we skip if it's missing or empty.
if (_is_constant_string(p_expression)) {
const PackedStringArray arr = p_expression->reduced_value.operator String().split(";", true, 1);
if (arr.size() >= 2) {
const String description = arr[1].strip_edges();
if (!description.is_empty()) {
_add_id(description, p_line);
}
}
}
}
void GDScriptEditorTranslationParserPlugin::_extract_fd_filter_array(const GDScriptParser::ExpressionNode *p_expression) {
const GDScriptParser::ArrayNode *array_node = nullptr;
if (p_expression->type == GDScriptParser::Node::ARRAY) {
// Extract from `["*.png ; PNG Images","*.gd ; GDScript Files"]` (implicit cast to `PackedStringArray`).
array_node = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
} else if (p_expression->type == GDScriptParser::Node::CALL) {
// Extract from `PackedStringArray(["*.png ; PNG Images","*.gd ; GDScript Files"])`.
const GDScriptParser::CallNode *call_node = static_cast<const GDScriptParser::CallNode *>(p_expression);
if (call_node->get_callee_type() == GDScriptParser::Node::IDENTIFIER && call_node->function_name == SNAME("PackedStringArray") && !call_node->arguments.is_empty() && call_node->arguments[0]->type == GDScriptParser::Node::ARRAY) {
array_node = static_cast<const GDScriptParser::ArrayNode *>(call_node->arguments[0]);
}
}
if (array_node) {
for (int i = 0; i < array_node->elements.size(); i++) {
_extract_fd_filter_string(array_node->elements[i], array_node->elements[i]->start_line);
}
}
}
GDScriptEditorTranslationParserPlugin::GDScriptEditorTranslationParserPlugin() {
assignment_patterns.insert("text");
assignment_patterns.insert("placeholder_text");
assignment_patterns.insert("tooltip_text");
first_arg_patterns.insert("set_text");
first_arg_patterns.insert("set_tooltip_text");
first_arg_patterns.insert("set_placeholder");
first_arg_patterns.insert("add_tab");
first_arg_patterns.insert("add_check_item");
first_arg_patterns.insert("add_item");
first_arg_patterns.insert("add_multistate_item");
first_arg_patterns.insert("add_radio_check_item");
first_arg_patterns.insert("add_separator");
first_arg_patterns.insert("add_submenu_item");
second_arg_patterns.insert("set_tab_title");
second_arg_patterns.insert("add_icon_check_item");
second_arg_patterns.insert("add_icon_item");
second_arg_patterns.insert("add_icon_radio_check_item");
second_arg_patterns.insert("set_item_text");
}

83
engine/modules/gdscript/editor/gdscript_translation_parser_plugin.h
View file

@ -1,83 +0,0 @@
/**************************************************************************/
/* gdscript_translation_parser_plugin.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
#pragma once
#include "../gdscript_parser.h"
#include "../gdscript_tokenizer.h"
#include "core/templates/hash_map.h"
#include "core/templates/hash_set.h"
#include "editor/translations/editor_translation_parser.h"
class GDScriptEditorTranslationParserPlugin : public EditorTranslationParserPlugin {
GDCLASS(GDScriptEditorTranslationParserPlugin, EditorTranslationParserPlugin);
const HashMap<int, GDScriptTokenizer::CommentData> *comment_data = nullptr;
Vector<Vector<String>> *translations = nullptr;
// List of patterns used for extracting translation strings.
StringName tr_func = "tr";
StringName trn_func = "tr_n";
StringName atr_func = "atr";
StringName atrn_func = "atr_n";
HashSet<StringName> assignment_patterns;
HashSet<StringName> first_arg_patterns;
HashSet<StringName> second_arg_patterns;
// FileDialog patterns.
StringName fd_add_filter = "add_filter";
StringName fd_set_filter = "set_filters";
StringName fd_filters = "filters";
static bool _is_constant_string(const GDScriptParser::ExpressionNode *p_expression);
String _parse_comment(int p_line, bool &r_skip) const;
void _add_id(const String &p_id, int p_line);
void _add_id_ctx_plural(const Vector<String> &p_id_ctx_plural, int p_line);
void _traverse_class(const GDScriptParser::ClassNode *p_class);
void _traverse_function(const GDScriptParser::FunctionNode *p_func);
void _traverse_block(const GDScriptParser::SuiteNode *p_suite);
void _assess_expression(const GDScriptParser::ExpressionNode *p_expression);
void _assess_assignment(const GDScriptParser::AssignmentNode *p_assignment);
void _assess_call(const GDScriptParser::CallNode *p_call);
void _extract_fd_filter_string(const GDScriptParser::ExpressionNode *p_expression, int p_line);
void _extract_fd_filter_array(const GDScriptParser::ExpressionNode *p_expression);
public:
virtual Error parse_file(const String &p_path, Vector<Vector<String>> *r_translations) override;
virtual void get_recognized_extensions(List<String> *r_extensions) const override;
GDScriptEditorTranslationParserPlugin();
};

27
engine/modules/gdscript/editor/script_templates/CharacterBody2D/basic_movement.gd
View file

@ -1,27 +0,0 @@
# meta-description: Classic movement for gravity games (platformer, ...)
extends _BASE_
const SPEED = 300.0
const JUMP_VELOCITY = -400.0
func _physics_process(delta: float) -> void:
# Add the gravity.
if not is_on_floor():
velocity += get_gravity() * delta
# Handle jump.
if Input.is_action_just_pressed("ui_accept") and is_on_floor():
velocity.y = JUMP_VELOCITY
# Get the input direction and handle the movement/deceleration.
# As good practice, you should replace UI actions with custom gameplay actions.
var direction := Input.get_axis("ui_left", "ui_right")
if direction:
velocity.x = direction * SPEED
else:
velocity.x = move_toward(velocity.x, 0, SPEED)
move_and_slide()

30
engine/modules/gdscript/editor/script_templates/CharacterBody3D/basic_movement.gd
View file

@ -1,30 +0,0 @@
# meta-description: Classic movement for gravity games (FPS, TPS, ...)
extends _BASE_
const SPEED = 5.0
const JUMP_VELOCITY = 4.5
func _physics_process(delta: float) -> void:
# Add the gravity.
if not is_on_floor():
velocity += get_gravity() * delta
# Handle jump.
if Input.is_action_just_pressed("ui_accept") and is_on_floor():
velocity.y = JUMP_VELOCITY
# Get the input direction and handle the movement/deceleration.
# As good practice, you should replace UI actions with custom gameplay actions.
var input_dir := Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
var direction := (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
if direction:
velocity.x = direction.x * SPEED
velocity.z = direction.z * SPEED
else:
velocity.x = move_toward(velocity.x, 0, SPEED)
velocity.z = move_toward(velocity.z, 0, SPEED)
move_and_slide()

24
engine/modules/gdscript/editor/script_templates/EditorPlugin/plugin.gd
View file

@ -1,24 +0,0 @@
# meta-description: Basic plugin template
@tool
extends _BASE_
func _enable_plugin() -> void:
# Add autoloads here.
pass
func _disable_plugin() -> void:
# Remove autoloads here.
pass
func _enter_tree() -> void:
# Initialization of the plugin goes here.
pass
func _exit_tree() -> void:
# Clean-up of the plugin goes here.
pass

10
engine/modules/gdscript/editor/script_templates/EditorScenePostImport/basic_import_script.gd
View file

@ -1,10 +0,0 @@
# meta-description: Basic import script template
@tool
extends _BASE_
# Called by the editor when a scene has this script set as the import script in the import tab.
func _post_import(scene: Node) -> Object:
# Modify the contents of the scene upon import.
return scene # Return the modified root node when you're done.

8
engine/modules/gdscript/editor/script_templates/EditorScenePostImport/no_comments.gd
View file

@ -1,8 +0,0 @@
# meta-description: Basic import script template (no comments)
@tool
extends _BASE_
func _post_import(scene: Node) -> Object:
return scene

9
engine/modules/gdscript/editor/script_templates/EditorScript/basic_editor_script.gd
View file

@ -1,9 +0,0 @@
# meta-description: Basic editor script template
@tool
extends _BASE_
# Called when the script is executed (using File -> Run in Script Editor).
func _run() -> void:
pass

13
engine/modules/gdscript/editor/script_templates/Node/default.gd
View file

@ -1,13 +0,0 @@
# meta-description: Base template for Node with default Godot cycle methods
extends _BASE_
# Called when the node enters the scene tree for the first time.
func _ready() -> void:
pass # Replace with function body.
# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
pass

3
engine/modules/gdscript/editor/script_templates/Object/empty.gd
View file

@ -1,3 +0,0 @@
# meta-description: Empty template suitable for all Objects
extends _BASE_

18
engine/modules/gdscript/editor/script_templates/RichTextEffect/default.gd
View file

@ -1,18 +0,0 @@
# meta-description: Base template for rich text effects
@tool
# Having a class name is handy for picking the effect in the Inspector.
class_name RichText_CLASS_
extends _BASE_
# To use this effect:
# - Enable BBCode on a RichTextLabel.
# - Register this effect on the label.
# - Use [_CLASS_SNAKE_CASE_ param=2.0]hello[/_CLASS_SNAKE_CASE_] in text.
var bbcode := "_CLASS_SNAKE_CASE_"
func _process_custom_fx(char_fx: CharFXTransform) -> bool:
var param: float = char_fx.env.get("param", 1.0)
return true

8
engine/modules/gdscript/editor/script_templates/SCsub
View file

@ -1,8 +0,0 @@
#!/usr/bin/env python
from misc.utility.scons_hints import *
Import("env")
import editor.template_builders as build_template_gd
env.CommandNoCache("templates.gen.h", Glob("*/*.gd"), env.Run(build_template_gd.make_templates))

51
engine/modules/gdscript/editor/script_templates/VisualShaderNodeCustom/basic.gd
View file

@ -1,51 +0,0 @@
# meta-description: Visual shader's node plugin template
@tool
# Having a class name is required for a custom node.
class_name VisualShaderNode_CLASS_
extends _BASE_
func _get_name() -> String:
return "_CLASS_"
func _get_category() -> String:
return ""
func _get_description() -> String:
return ""
func _get_return_icon_type() -> PortType:
return PORT_TYPE_SCALAR
func _get_input_port_count() -> int:
return 0
func _get_input_port_name(port: int) -> String:
return ""
func _get_input_port_type(port: int) -> PortType:
return PORT_TYPE_SCALAR
func _get_output_port_count() -> int:
return 1
func _get_output_port_name(port: int) -> String:
return "result"
func _get_output_port_type(port: int) -> PortType:
return PORT_TYPE_SCALAR
func _get_code(input_vars: Array[String], output_vars: Array[String],
mode: Shader.Mode, type: VisualShader.Type) -> String:
return output_vars[0] + " = 0.0;"