mirror of
https://github.com/godotengine/godot.git
synced 2024-11-15 08:32:54 +00:00
Merge pull request #47454 from vnen/gdscript-lambda
This commit is contained in:
Rémi Verschelde
GitHub
commit
f505a26798
@ -270,6 +270,7 @@ public:
|
||||
class GDScriptInstance : public ScriptInstance {
|
||||
friend class GDScript;
|
||||
friend class GDScriptFunction;
|
||||
friend class GDScriptLambdaCallable;
|
||||
friend class GDScriptCompiler;
|
||||
friend struct GDScriptUtilityFunctionsDefinitions;
|
||||
|
||||
|
||||
@ -856,6 +856,7 @@ void GDScriptAnalyzer::resolve_node(GDScriptParser::Node *p_node) {
|
||||
case GDScriptParser::Node::DICTIONARY:
|
||||
case GDScriptParser::Node::GET_NODE:
|
||||
case GDScriptParser::Node::IDENTIFIER:
|
||||
case GDScriptParser::Node::LAMBDA:
|
||||
case GDScriptParser::Node::LITERAL:
|
||||
case GDScriptParser::Node::PRELOAD:
|
||||
case GDScriptParser::Node::SELF:
|
||||
@ -1458,6 +1459,9 @@ void GDScriptAnalyzer::reduce_expression(GDScriptParser::ExpressionNode *p_expre
|
||||
case GDScriptParser::Node::IDENTIFIER:
|
||||
reduce_identifier(static_cast<GDScriptParser::IdentifierNode *>(p_expression));
|
||||
break;
|
||||
case GDScriptParser::Node::LAMBDA:
|
||||
reduce_lambda(static_cast<GDScriptParser::LambdaNode *>(p_expression));
|
||||
break;
|
||||
case GDScriptParser::Node::LITERAL:
|
||||
reduce_literal(static_cast<GDScriptParser::LiteralNode *>(p_expression));
|
||||
break;
|
||||
@ -2061,6 +2065,12 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool is_awa
|
||||
is_self = true;
|
||||
} else if (callee_type == GDScriptParser::Node::SUBSCRIPT) {
|
||||
GDScriptParser::SubscriptNode *subscript = static_cast<GDScriptParser::SubscriptNode *>(p_call->callee);
|
||||
if (subscript->base == nullptr) {
|
||||
// Invalid syntax, error already set on parser.
|
||||
p_call->set_datatype(call_type);
|
||||
mark_node_unsafe(p_call);
|
||||
return;
|
||||
}
|
||||
if (!subscript->is_attribute) {
|
||||
// Invalid call. Error already sent in parser.
|
||||
// TODO: Could check if Callable here.
|
||||
@ -2097,6 +2107,8 @@ void GDScriptAnalyzer::reduce_call(GDScriptParser::CallNode *p_call, bool is_awa
|
||||
|
||||
if (is_self && parser->current_function != nullptr && parser->current_function->is_static && !is_static) {
|
||||
push_error(vformat(R"*(Cannot call non-static function "%s()" from static function "%s()".)*", p_call->function_name, parser->current_function->identifier->name), p_call->callee);
|
||||
} else if (is_self && !is_static && !lambda_stack.is_empty()) {
|
||||
push_error(vformat(R"*(Cannot call non-static function "%s()" from a lambda function.)*", p_call->function_name), p_call->callee);
|
||||
}
|
||||
|
||||
call_type = return_type;
|
||||
@ -2219,6 +2231,8 @@ void GDScriptAnalyzer::reduce_get_node(GDScriptParser::GetNodeNode *p_get_node)
|
||||
|
||||
if (!ClassDB::is_parent_class(GDScriptParser::get_real_class_name(parser->current_class->base_type.native_type), result.native_type)) {
|
||||
push_error(R"*(Cannot use shorthand "get_node()" notation ("$") on a class that isn't a node.)*", p_get_node);
|
||||
} else if (!lambda_stack.is_empty()) {
|
||||
push_error(R"*(Cannot use shorthand "get_node()" notation ("$") inside a lambda. Use a captured variable instead.)*", p_get_node);
|
||||
}
|
||||
|
||||
p_get_node->set_datatype(result);
|
||||
@ -2346,6 +2360,7 @@ void GDScriptAnalyzer::reduce_identifier_from_base(GDScriptParser::IdentifierNod
|
||||
case GDScriptParser::ClassNode::Member::ENUM_VALUE:
|
||||
p_identifier->is_constant = true;
|
||||
p_identifier->reduced_value = member.enum_value.value;
|
||||
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_CONSTANT;
|
||||
break;
|
||||
case GDScriptParser::ClassNode::Member::VARIABLE:
|
||||
p_identifier->source = GDScriptParser::IdentifierNode::MEMBER_VARIABLE;
|
||||
@ -2446,42 +2461,65 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
|
||||
}
|
||||
}
|
||||
|
||||
bool found_source = false;
|
||||
// Check if identifier is local.
|
||||
// If that's the case, the declaration already was solved before.
|
||||
switch (p_identifier->source) {
|
||||
case GDScriptParser::IdentifierNode::FUNCTION_PARAMETER:
|
||||
p_identifier->set_datatype(p_identifier->parameter_source->get_datatype());
|
||||
return;
|
||||
found_source = true;
|
||||
break;
|
||||
case GDScriptParser::IdentifierNode::LOCAL_CONSTANT:
|
||||
case GDScriptParser::IdentifierNode::MEMBER_CONSTANT:
|
||||
p_identifier->set_datatype(p_identifier->constant_source->get_datatype());
|
||||
p_identifier->is_constant = true;
|
||||
// TODO: Constant should have a value on the node itself.
|
||||
p_identifier->reduced_value = p_identifier->constant_source->initializer->reduced_value;
|
||||
return;
|
||||
found_source = true;
|
||||
break;
|
||||
case GDScriptParser::IdentifierNode::MEMBER_VARIABLE:
|
||||
p_identifier->variable_source->usages++;
|
||||
[[fallthrough]];
|
||||
case GDScriptParser::IdentifierNode::LOCAL_VARIABLE:
|
||||
p_identifier->set_datatype(p_identifier->variable_source->get_datatype());
|
||||
return;
|
||||
found_source = true;
|
||||
break;
|
||||
case GDScriptParser::IdentifierNode::LOCAL_ITERATOR:
|
||||
p_identifier->set_datatype(p_identifier->bind_source->get_datatype());
|
||||
return;
|
||||
found_source = true;
|
||||
break;
|
||||
case GDScriptParser::IdentifierNode::LOCAL_BIND: {
|
||||
GDScriptParser::DataType result = p_identifier->bind_source->get_datatype();
|
||||
result.is_constant = true;
|
||||
p_identifier->set_datatype(result);
|
||||
return;
|
||||
}
|
||||
found_source = true;
|
||||
} break;
|
||||
case GDScriptParser::IdentifierNode::UNDEFINED_SOURCE:
|
||||
break;
|
||||
}
|
||||
|
||||
// Not a local, so check members.
|
||||
reduce_identifier_from_base(p_identifier);
|
||||
if (p_identifier->get_datatype().is_set()) {
|
||||
// Found.
|
||||
if (!found_source) {
|
||||
reduce_identifier_from_base(p_identifier);
|
||||
if (p_identifier->source != GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->get_datatype().is_set()) {
|
||||
// Found.
|
||||
found_source = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (found_source) {
|
||||
// If the identifier is local, check if it's any kind of capture by comparing their source function.
|
||||
// Only capture locals and members and enum values. Constants are still accessible from the lambda using the script reference.
|
||||
if (p_identifier->source == GDScriptParser::IdentifierNode::UNDEFINED_SOURCE || p_identifier->source == GDScriptParser::IdentifierNode::MEMBER_CONSTANT || lambda_stack.is_empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
GDScriptParser::FunctionNode *function_test = lambda_stack.back()->get()->function;
|
||||
while (function_test != nullptr && function_test != p_identifier->source_function && function_test->source_lambda != nullptr && !function_test->source_lambda->captures_indices.has(p_identifier->name)) {
|
||||
function_test->source_lambda->captures_indices[p_identifier->name] = function_test->source_lambda->captures.size();
|
||||
function_test->source_lambda->captures.push_back(p_identifier);
|
||||
function_test = function_test->source_lambda->parent_function;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@ -2563,6 +2601,57 @@ void GDScriptAnalyzer::reduce_identifier(GDScriptParser::IdentifierNode *p_ident
|
||||
p_identifier->set_datatype(dummy); // Just so type is set to something.
|
||||
}
|
||||
|
||||
void GDScriptAnalyzer::reduce_lambda(GDScriptParser::LambdaNode *p_lambda) {
|
||||
// Lambda is always a Callable.
|
||||
GDScriptParser::DataType lambda_type;
|
||||
lambda_type.type_source = GDScriptParser::DataType::ANNOTATED_INFERRED;
|
||||
lambda_type.kind = GDScriptParser::DataType::BUILTIN;
|
||||
lambda_type.builtin_type = Variant::CALLABLE;
|
||||
p_lambda->set_datatype(lambda_type);
|
||||
|
||||
if (p_lambda->function == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
GDScriptParser::FunctionNode *previous_function = parser->current_function;
|
||||
parser->current_function = p_lambda->function;
|
||||
|
||||
lambda_stack.push_back(p_lambda);
|
||||
|
||||
for (int i = 0; i < p_lambda->function->parameters.size(); i++) {
|
||||
resolve_parameter(p_lambda->function->parameters[i]);
|
||||
}
|
||||
|
||||
resolve_suite(p_lambda->function->body);
|
||||
|
||||
int captures_amount = p_lambda->captures.size();
|
||||
if (captures_amount > 0) {
|
||||
// Create space for lambda parameters.
|
||||
// At the beginning to not mess with optional parameters.
|
||||
int param_count = p_lambda->function->parameters.size();
|
||||
p_lambda->function->parameters.resize(param_count + captures_amount);
|
||||
for (int i = param_count - 1; i >= 0; i--) {
|
||||
p_lambda->function->parameters.write[i + captures_amount] = p_lambda->function->parameters[i];
|
||||
p_lambda->function->parameters_indices[p_lambda->function->parameters[i]->identifier->name] = i + captures_amount;
|
||||
}
|
||||
|
||||
// Add captures as extra parameters at the beginning.
|
||||
for (int i = 0; i < p_lambda->captures.size(); i++) {
|
||||
GDScriptParser::IdentifierNode *capture = p_lambda->captures[i];
|
||||
GDScriptParser::ParameterNode *capture_param = parser->alloc_node<GDScriptParser::ParameterNode>();
|
||||
capture_param->identifier = capture;
|
||||
capture_param->usages = capture->usages;
|
||||
capture_param->set_datatype(capture->get_datatype());
|
||||
|
||||
p_lambda->function->parameters.write[i] = capture_param;
|
||||
p_lambda->function->parameters_indices[capture->name] = i;
|
||||
}
|
||||
}
|
||||
|
||||
lambda_stack.pop_back();
|
||||
parser->current_function = previous_function;
|
||||
}
|
||||
|
||||
void GDScriptAnalyzer::reduce_literal(GDScriptParser::LiteralNode *p_literal) {
|
||||
p_literal->reduced_value = p_literal->value;
|
||||
p_literal->is_constant = true;
|
||||
|
||||
@ -42,6 +42,7 @@ class GDScriptAnalyzer {
|
||||
HashMap<String, Ref<GDScriptParserRef>> depended_parsers;
|
||||
|
||||
const GDScriptParser::EnumNode *current_enum = nullptr;
|
||||
List<const GDScriptParser::LambdaNode *> lambda_stack;
|
||||
|
||||
Error resolve_inheritance(GDScriptParser::ClassNode *p_class, bool p_recursive = true);
|
||||
GDScriptParser::DataType resolve_datatype(GDScriptParser::TypeNode *p_type);
|
||||
@ -82,6 +83,7 @@ class GDScriptAnalyzer {
|
||||
void reduce_get_node(GDScriptParser::GetNodeNode *p_get_node);
|
||||
void reduce_identifier(GDScriptParser::IdentifierNode *p_identifier, bool can_be_builtin = false);
|
||||
void reduce_identifier_from_base(GDScriptParser::IdentifierNode *p_identifier, GDScriptParser::DataType *p_base = nullptr);
|
||||
void reduce_lambda(GDScriptParser::LambdaNode *p_lambda);
|
||||
void reduce_literal(GDScriptParser::LiteralNode *p_literal);
|
||||
void reduce_preload(GDScriptParser::PreloadNode *p_preload);
|
||||
void reduce_self(GDScriptParser::SelfNode *p_self);
|
||||
|
||||
@ -383,6 +383,18 @@ GDScriptFunction *GDScriptByteCodeGenerator::write_end() {
|
||||
function->_methods_count = 0;
|
||||
}
|
||||
|
||||
if (lambdas_map.size()) {
|
||||
function->lambdas.resize(lambdas_map.size());
|
||||
function->_lambdas_ptr = function->lambdas.ptrw();
|
||||
function->_lambdas_count = lambdas_map.size();
|
||||
for (const Map<GDScriptFunction *, int>::Element *E = lambdas_map.front(); E; E = E->next()) {
|
||||
function->lambdas.write[E->get()] = E->key();
|
||||
}
|
||||
} else {
|
||||
function->_lambdas_ptr = nullptr;
|
||||
function->_lambdas_count = 0;
|
||||
}
|
||||
|
||||
if (debug_stack) {
|
||||
function->stack_debug = stack_debug;
|
||||
}
|
||||
@ -1118,6 +1130,17 @@ void GDScriptByteCodeGenerator::write_call_script_function(const Address &p_targ
|
||||
append(p_function_name);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures) {
|
||||
append(GDScriptFunction::OPCODE_CREATE_LAMBDA, 1 + p_captures.size());
|
||||
for (int i = 0; i < p_captures.size(); i++) {
|
||||
append(p_captures[i]);
|
||||
}
|
||||
|
||||
append(p_target);
|
||||
append(p_captures.size());
|
||||
append(p_function);
|
||||
}
|
||||
|
||||
void GDScriptByteCodeGenerator::write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) {
|
||||
// Try to find an appropriate constructor.
|
||||
bool all_have_type = true;
|
||||
|
||||
@ -93,6 +93,7 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
|
||||
Map<Variant::ValidatedUtilityFunction, int> utilities_map;
|
||||
Map<GDScriptUtilityFunctions::FunctionPtr, int> gds_utilities_map;
|
||||
Map<MethodBind *, int> method_bind_map;
|
||||
Map<GDScriptFunction *, int> lambdas_map;
|
||||
|
||||
// Lists since these can be nested.
|
||||
List<int> if_jmp_addrs;
|
||||
@ -293,6 +294,15 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
|
||||
return pos;
|
||||
}
|
||||
|
||||
int get_lambda_function_pos(GDScriptFunction *p_lambda_function) {
|
||||
if (lambdas_map.has(p_lambda_function)) {
|
||||
return lambdas_map[p_lambda_function];
|
||||
}
|
||||
int pos = lambdas_map.size();
|
||||
lambdas_map[p_lambda_function] = pos;
|
||||
return pos;
|
||||
}
|
||||
|
||||
void alloc_ptrcall(int p_params) {
|
||||
if (p_params >= ptrcall_max) {
|
||||
ptrcall_max = p_params;
|
||||
@ -386,6 +396,10 @@ class GDScriptByteCodeGenerator : public GDScriptCodeGenerator {
|
||||
opcodes.push_back(get_method_bind_pos(p_method));
|
||||
}
|
||||
|
||||
void append(GDScriptFunction *p_lambda_function) {
|
||||
opcodes.push_back(get_lambda_function_pos(p_lambda_function));
|
||||
}
|
||||
|
||||
void patch_jump(int p_address) {
|
||||
opcodes.write[p_address] = opcodes.size();
|
||||
}
|
||||
@ -452,6 +466,7 @@ public:
|
||||
virtual void write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
|
||||
virtual void write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
|
||||
virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) override;
|
||||
virtual void write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures) override;
|
||||
virtual void write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) override;
|
||||
virtual void write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) override;
|
||||
virtual void write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) override;
|
||||
|
||||
@ -127,6 +127,7 @@ public:
|
||||
virtual void write_call_self(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
|
||||
virtual void write_call_self_async(const Address &p_target, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
|
||||
virtual void write_call_script_function(const Address &p_target, const Address &p_base, const StringName &p_function_name, const Vector<Address> &p_arguments) = 0;
|
||||
virtual void write_lambda(const Address &p_target, GDScriptFunction *p_function, const Vector<Address> &p_captures) = 0;
|
||||
virtual void write_construct(const Address &p_target, Variant::Type p_type, const Vector<Address> &p_arguments) = 0;
|
||||
virtual void write_construct_array(const Address &p_target, const Vector<Address> &p_arguments) = 0;
|
||||
virtual void write_construct_typed_array(const Address &p_target, const GDScriptDataType &p_element_type, const Vector<Address> &p_arguments) = 0;
|
||||
|
||||
@ -1091,6 +1091,34 @@ GDScriptCodeGenerator::Address GDScriptCompiler::_parse_expression(CodeGen &code
|
||||
}
|
||||
return GDScriptCodeGenerator::Address(); // Assignment does not return a value.
|
||||
} break;
|
||||
case GDScriptParser::Node::LAMBDA: {
|
||||
const GDScriptParser::LambdaNode *lambda = static_cast<const GDScriptParser::LambdaNode *>(p_expression);
|
||||
GDScriptCodeGenerator::Address result = codegen.add_temporary(_gdtype_from_datatype(lambda->get_datatype()));
|
||||
|
||||
Vector<GDScriptCodeGenerator::Address> captures;
|
||||
captures.resize(lambda->captures.size());
|
||||
for (int i = 0; i < lambda->captures.size(); i++) {
|
||||
captures.write[i] = _parse_expression(codegen, r_error, lambda->captures[i]);
|
||||
if (r_error) {
|
||||
return GDScriptCodeGenerator::Address();
|
||||
}
|
||||
}
|
||||
|
||||
GDScriptFunction *function = _parse_function(r_error, codegen.script, codegen.class_node, lambda->function, false, true);
|
||||
if (r_error) {
|
||||
return GDScriptCodeGenerator::Address();
|
||||
}
|
||||
|
||||
gen->write_lambda(result, function, captures);
|
||||
|
||||
for (int i = 0; i < captures.size(); i++) {
|
||||
if (captures[i].mode == GDScriptCodeGenerator::Address::TEMPORARY) {
|
||||
gen->pop_temporary();
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
} break;
|
||||
default: {
|
||||
ERR_FAIL_V_MSG(GDScriptCodeGenerator::Address(), "Bug in bytecode compiler, unexpected node in parse tree while parsing expression."); // Unreachable code.
|
||||
} break;
|
||||
@ -1804,8 +1832,8 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Sui
|
||||
return OK;
|
||||
}
|
||||
|
||||
Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready) {
|
||||
Error error = OK;
|
||||
GDScriptFunction *GDScriptCompiler::_parse_function(Error &r_error, GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready, bool p_for_lambda) {
|
||||
r_error = OK;
|
||||
CodeGen codegen;
|
||||
codegen.generator = memnew(GDScriptByteCodeGenerator);
|
||||
|
||||
@ -1822,7 +1850,11 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
return_type.builtin_type = Variant::NIL;
|
||||
|
||||
if (p_func) {
|
||||
func_name = p_func->identifier->name;
|
||||
if (p_func->identifier) {
|
||||
func_name = p_func->identifier->name;
|
||||
} else {
|
||||
func_name = "<anonymous lambda>";
|
||||
}
|
||||
is_static = p_func->is_static;
|
||||
rpc_mode = p_func->rpc_mode;
|
||||
return_type = _gdtype_from_datatype(p_func->get_datatype(), p_script);
|
||||
@ -1853,11 +1885,11 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
}
|
||||
|
||||
// Parse initializer if applies.
|
||||
bool is_implicit_initializer = !p_for_ready && !p_func;
|
||||
bool is_initializer = p_func && String(p_func->identifier->name) == GDScriptLanguage::get_singleton()->strings._init;
|
||||
bool is_for_ready = p_for_ready || (p_func && String(p_func->identifier->name) == "_ready");
|
||||
bool is_implicit_initializer = !p_for_ready && !p_func && !p_for_lambda;
|
||||
bool is_initializer = p_func && !p_for_lambda && String(p_func->identifier->name) == GDScriptLanguage::get_singleton()->strings._init;
|
||||
bool is_for_ready = p_for_ready || (p_func && !p_for_lambda && String(p_func->identifier->name) == "_ready");
|
||||
|
||||
if (is_implicit_initializer || is_for_ready) {
|
||||
if (!p_for_lambda && (is_implicit_initializer || is_for_ready)) {
|
||||
// Initialize class fields.
|
||||
for (int i = 0; i < p_class->members.size(); i++) {
|
||||
if (p_class->members[i].type != GDScriptParser::ClassNode::Member::VARIABLE) {
|
||||
@ -1884,10 +1916,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
codegen.generator->write_construct_array(dst_address, Vector<GDScriptCodeGenerator::Address>());
|
||||
}
|
||||
}
|
||||
GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, error, field->initializer, false, true);
|
||||
if (error) {
|
||||
GDScriptCodeGenerator::Address src_address = _parse_expression(codegen, r_error, field->initializer, false, true);
|
||||
if (r_error) {
|
||||
memdelete(codegen.generator);
|
||||
return error;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
codegen.generator->write_assign(dst_address, src_address);
|
||||
@ -1914,10 +1946,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
codegen.generator->start_parameters();
|
||||
for (int i = p_func->parameters.size() - optional_parameters; i < p_func->parameters.size(); i++) {
|
||||
const GDScriptParser::ParameterNode *parameter = p_func->parameters[i];
|
||||
GDScriptCodeGenerator::Address src_addr = _parse_expression(codegen, error, parameter->default_value, true);
|
||||
if (error) {
|
||||
GDScriptCodeGenerator::Address src_addr = _parse_expression(codegen, r_error, parameter->default_value, true);
|
||||
if (r_error) {
|
||||
memdelete(codegen.generator);
|
||||
return error;
|
||||
return nullptr;
|
||||
}
|
||||
GDScriptCodeGenerator::Address dst_addr = codegen.parameters[parameter->identifier->name];
|
||||
codegen.generator->write_assign_default_parameter(dst_addr, src_addr);
|
||||
@ -1928,10 +1960,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
codegen.generator->end_parameters();
|
||||
}
|
||||
|
||||
Error err = _parse_block(codegen, p_func->body);
|
||||
if (err) {
|
||||
r_error = _parse_block(codegen, p_func->body);
|
||||
if (r_error) {
|
||||
memdelete(codegen.generator);
|
||||
return err;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1957,6 +1989,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
signature += "::" + String(func_name);
|
||||
}
|
||||
|
||||
if (p_for_lambda) {
|
||||
signature += "(lambda)";
|
||||
}
|
||||
|
||||
codegen.generator->set_signature(signature);
|
||||
}
|
||||
#endif
|
||||
@ -1964,8 +2000,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
if (p_func) {
|
||||
codegen.generator->set_initial_line(p_func->start_line);
|
||||
#ifdef TOOLS_ENABLED
|
||||
p_script->member_lines[func_name] = p_func->start_line;
|
||||
p_script->doc_functions[func_name] = p_func->doc_description;
|
||||
if (!p_for_lambda) {
|
||||
p_script->member_lines[func_name] = p_func->start_line;
|
||||
p_script->doc_functions[func_name] = p_func->doc_description;
|
||||
}
|
||||
#endif
|
||||
} else {
|
||||
codegen.generator->set_initial_line(0);
|
||||
@ -1994,11 +2032,13 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
|
||||
#endif
|
||||
}
|
||||
|
||||
p_script->member_functions[func_name] = gd_function;
|
||||
if (!p_for_lambda) {
|
||||
p_script->member_functions[func_name] = gd_function;
|
||||
}
|
||||
|
||||
memdelete(codegen.generator);
|
||||
|
||||
return OK;
|
||||
return gd_function;
|
||||
}
|
||||
|
||||
Error GDScriptCompiler::_parse_setter_getter(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::VariableNode *p_variable, bool p_is_setter) {
|
||||
@ -2391,7 +2431,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
|
||||
if (!has_ready && function->identifier->name == "_ready") {
|
||||
has_ready = true;
|
||||
}
|
||||
Error err = _parse_function(p_script, p_class, function);
|
||||
Error err = OK;
|
||||
_parse_function(err, p_script, p_class, function);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
@ -2416,7 +2457,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
|
||||
|
||||
{
|
||||
// Create an implicit constructor in any case.
|
||||
Error err = _parse_function(p_script, p_class, nullptr);
|
||||
Error err = OK;
|
||||
_parse_function(err, p_script, p_class, nullptr);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
@ -2424,7 +2466,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
|
||||
|
||||
if (!has_ready && p_class->onready_used) {
|
||||
//create a _ready constructor
|
||||
Error err = _parse_function(p_script, p_class, nullptr, true);
|
||||
Error err = OK;
|
||||
_parse_function(err, p_script, p_class, nullptr, true);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
@ -128,7 +128,7 @@ class GDScriptCompiler {
|
||||
GDScriptCodeGenerator::Address _parse_match_pattern(CodeGen &codegen, Error &r_error, const GDScriptParser::PatternNode *p_pattern, const GDScriptCodeGenerator::Address &p_value_addr, const GDScriptCodeGenerator::Address &p_type_addr, const GDScriptCodeGenerator::Address &p_previous_test, bool p_is_first, bool p_is_nested);
|
||||
void _add_locals_in_block(CodeGen &codegen, const GDScriptParser::SuiteNode *p_block);
|
||||
Error _parse_block(CodeGen &codegen, const GDScriptParser::SuiteNode *p_block, bool p_add_locals = true);
|
||||
Error _parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready = false);
|
||||
GDScriptFunction *_parse_function(Error &r_error, GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready = false, bool p_for_lambda = false);
|
||||
Error _parse_setter_getter(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::VariableNode *p_variable, bool p_is_setter);
|
||||
Error _parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
|
||||
Error _parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
|
||||
|
||||
@ -721,7 +721,7 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
||||
text += "await ";
|
||||
text += DADDR(1);
|
||||
|
||||
incr += 2;
|
||||
incr = 2;
|
||||
} break;
|
||||
case OPCODE_AWAIT_RESUME: {
|
||||
text += "await resume ";
|
||||
@ -729,6 +729,25 @@ void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
|
||||
|
||||
incr = 2;
|
||||
} break;
|
||||
case OPCODE_CREATE_LAMBDA: {
|
||||
int captures_count = _code_ptr[ip + 1 + instr_var_args];
|
||||
GDScriptFunction *lambda = _lambdas_ptr[_code_ptr[ip + 2 + instr_var_args]];
|
||||
|
||||
text += DADDR(1 + captures_count);
|
||||
text += "create lambda from ";
|
||||
text += lambda->name.operator String();
|
||||
text += "function, captures (";
|
||||
|
||||
for (int i = 0; i < captures_count; i++) {
|
||||
if (i > 0) {
|
||||
text += ", ";
|
||||
}
|
||||
text += DADDR(1 + i);
|
||||
}
|
||||
text += ")";
|
||||
|
||||
incr = 3 + captures_count;
|
||||
} break;
|
||||
case OPCODE_JUMP: {
|
||||
text += "jump ";
|
||||
text += itos(_code_ptr[ip + 1]);
|
||||
|
||||
@ -150,6 +150,10 @@ GDScriptFunction::GDScriptFunction() {
|
||||
}
|
||||
|
||||
GDScriptFunction::~GDScriptFunction() {
|
||||
for (int i = 0; i < lambdas.size(); i++) {
|
||||
memdelete(lambdas[i]);
|
||||
}
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
|
||||
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
|
||||
|
||||
@ -301,6 +301,7 @@ public:
|
||||
OPCODE_CALL_PTRCALL_PACKED_COLOR_ARRAY,
|
||||
OPCODE_AWAIT,
|
||||
OPCODE_AWAIT_RESUME,
|
||||
OPCODE_CREATE_LAMBDA,
|
||||
OPCODE_JUMP,
|
||||
OPCODE_JUMP_IF,
|
||||
OPCODE_JUMP_IF_NOT,
|
||||
@ -459,6 +460,8 @@ private:
|
||||
const GDScriptUtilityFunctions::FunctionPtr *_gds_utilities_ptr = nullptr;
|
||||
int _methods_count = 0;
|
||||
MethodBind **_methods_ptr = nullptr;
|
||||
int _lambdas_count = 0;
|
||||
GDScriptFunction **_lambdas_ptr = nullptr;
|
||||
const int *_code_ptr = nullptr;
|
||||
int _code_size = 0;
|
||||
int _argument_count = 0;
|
||||
@ -488,6 +491,7 @@ private:
|
||||
Vector<Variant::ValidatedUtilityFunction> utilities;
|
||||
Vector<GDScriptUtilityFunctions::FunctionPtr> gds_utilities;
|
||||
Vector<MethodBind *> methods;
|
||||
Vector<GDScriptFunction *> lambdas;
|
||||
Vector<int> code;
|
||||
Vector<GDScriptDataType> argument_types;
|
||||
GDScriptDataType return_type;
|
||||
|
||||
95
modules/gdscript/gdscript_lambda_callable.cpp
Normal file
95
modules/gdscript/gdscript_lambda_callable.cpp
Normal file
@ -0,0 +1,95 @@
|
||||
/*************************************************************************/
|
||||
/* gdscript_lambda_callable.cpp */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2021 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 "gdscript_lambda_callable.h"
|
||||
|
||||
#include "core/templates/hashfuncs.h"
|
||||
#include "gdscript.h"
|
||||
|
||||
bool GDScriptLambdaCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
|
||||
// Lambda callables are only compared by reference.
|
||||
return p_a == p_b;
|
||||
}
|
||||
|
||||
bool GDScriptLambdaCallable::compare_less(const CallableCustom *p_a, const CallableCustom *p_b) {
|
||||
// Lambda callables are only compared by reference.
|
||||
return p_a < p_b;
|
||||
}
|
||||
|
||||
uint32_t GDScriptLambdaCallable::hash() const {
|
||||
return h;
|
||||
}
|
||||
|
||||
String GDScriptLambdaCallable::get_as_text() const {
|
||||
if (function->get_name() != StringName()) {
|
||||
return function->get_name().operator String() + "(lambda)";
|
||||
}
|
||||
return "(anonymous lambda)";
|
||||
}
|
||||
|
||||
CallableCustom::CompareEqualFunc GDScriptLambdaCallable::get_compare_equal_func() const {
|
||||
return compare_equal;
|
||||
}
|
||||
|
||||
CallableCustom::CompareLessFunc GDScriptLambdaCallable::get_compare_less_func() const {
|
||||
return compare_less;
|
||||
}
|
||||
|
||||
ObjectID GDScriptLambdaCallable::get_object() const {
|
||||
return script->get_instance_id();
|
||||
}
|
||||
|
||||
void GDScriptLambdaCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
|
||||
int captures_amount = captures.size();
|
||||
|
||||
if (captures_amount > 0) {
|
||||
Vector<const Variant *> args;
|
||||
args.resize(p_argcount + captures_amount);
|
||||
for (int i = 0; i < captures_amount; i++) {
|
||||
args.write[i] = &captures[i];
|
||||
}
|
||||
for (int i = 0; i < p_argcount; i++) {
|
||||
args.write[i + captures_amount] = p_arguments[i];
|
||||
}
|
||||
|
||||
r_return_value = function->call(nullptr, args.ptrw(), args.size(), r_call_error);
|
||||
r_call_error.argument -= captures_amount;
|
||||
} else {
|
||||
r_return_value = function->call(nullptr, p_arguments, p_argcount, r_call_error);
|
||||
}
|
||||
}
|
||||
|
||||
GDScriptLambdaCallable::GDScriptLambdaCallable(Ref<GDScript> p_script, GDScriptFunction *p_function, const Vector<Variant> &p_captures) {
|
||||
script = p_script;
|
||||
function = p_function;
|
||||
captures = p_captures;
|
||||
|
||||
h = (uint32_t)hash_djb2_one_64((uint64_t)this);
|
||||
}
|
||||
65
modules/gdscript/gdscript_lambda_callable.h
Normal file
65
modules/gdscript/gdscript_lambda_callable.h
Normal file
@ -0,0 +1,65 @@
|
||||
/*************************************************************************/
|
||||
/* gdscript_lambda_callable.h */
|
||||
/*************************************************************************/
|
||||
/* This file is part of: */
|
||||
/* GODOT ENGINE */
|
||||
/* https://godotengine.org */
|
||||
/*************************************************************************/
|
||||
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
||||
/* Copyright (c) 2014-2021 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 GDSCRIPT_LAMBDA_CALLABLE
|
||||
#define GDSCRIPT_LAMBDA_CALLABLE
|
||||
|
||||
#include "core/object/reference.h"
|
||||
#include "core/templates/vector.h"
|
||||
#include "core/variant/callable.h"
|
||||
#include "core/variant/variant.h"
|
||||
|
||||
class GDScript;
|
||||
class GDScriptFunction;
|
||||
class GDScriptInstance;
|
||||
|
||||
class GDScriptLambdaCallable : public CallableCustom {
|
||||
GDScriptFunction *function = nullptr;
|
||||
Ref<GDScript> script;
|
||||
uint32_t h;
|
||||
|
||||
Vector<Variant> captures;
|
||||
|
||||
static bool compare_equal(const CallableCustom *p_a, const CallableCustom *p_b);
|
||||
static bool compare_less(const CallableCustom *p_a, const CallableCustom *p_b);
|
||||
|
||||
public:
|
||||
uint32_t hash() const override;
|
||||
String get_as_text() const override;
|
||||
CompareEqualFunc get_compare_equal_func() const override;
|
||||
CompareLessFunc get_compare_less_func() const override;
|
||||
ObjectID get_object() const override;
|
||||
void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const override;
|
||||
|
||||
GDScriptLambdaCallable(Ref<GDScript> p_script, GDScriptFunction *p_function, const Vector<Variant> &p_captures);
|
||||
virtual ~GDScriptLambdaCallable() = default;
|
||||
};
|
||||
|
||||
#endif // GDSCRIPT_LAMBDA_CALLABLE
|
||||
@ -402,6 +402,8 @@ Error GDScriptParser::parse(const String &p_source_code, const String &p_script_
|
||||
}
|
||||
|
||||
GDScriptTokenizer::Token GDScriptParser::advance() {
|
||||
lambda_ended = false; // Empty marker since we're past the end in any case.
|
||||
|
||||
if (current.type == GDScriptTokenizer::Token::TK_EOF) {
|
||||
ERR_FAIL_COND_V_MSG(current.type == GDScriptTokenizer::Token::TK_EOF, current, "GDScript parser bug: Trying to advance past the end of stream.");
|
||||
}
|
||||
@ -428,7 +430,7 @@ bool GDScriptParser::match(GDScriptTokenizer::Token::Type p_token_type) {
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GDScriptParser::check(GDScriptTokenizer::Token::Type p_token_type) {
|
||||
bool GDScriptParser::check(GDScriptTokenizer::Token::Type p_token_type) const {
|
||||
if (p_token_type == GDScriptTokenizer::Token::IDENTIFIER) {
|
||||
return current.is_identifier();
|
||||
}
|
||||
@ -443,7 +445,7 @@ bool GDScriptParser::consume(GDScriptTokenizer::Token::Type p_token_type, const
|
||||
return false;
|
||||
}
|
||||
|
||||
bool GDScriptParser::is_at_end() {
|
||||
bool GDScriptParser::is_at_end() const {
|
||||
return check(GDScriptTokenizer::Token::TK_EOF);
|
||||
}
|
||||
|
||||
@ -494,16 +496,34 @@ void GDScriptParser::pop_multiline() {
|
||||
tokenizer.set_multiline_mode(multiline_stack.size() > 0 ? multiline_stack.back()->get() : false);
|
||||
}
|
||||
|
||||
bool GDScriptParser::is_statement_end() {
|
||||
bool GDScriptParser::is_statement_end_token() const {
|
||||
return check(GDScriptTokenizer::Token::NEWLINE) || check(GDScriptTokenizer::Token::SEMICOLON) || check(GDScriptTokenizer::Token::TK_EOF);
|
||||
}
|
||||
|
||||
bool GDScriptParser::is_statement_end() const {
|
||||
return lambda_ended || in_lambda || is_statement_end_token();
|
||||
}
|
||||
|
||||
void GDScriptParser::end_statement(const String &p_context) {
|
||||
bool found = false;
|
||||
while (is_statement_end() && !is_at_end()) {
|
||||
// Remove sequential newlines/semicolons.
|
||||
if (is_statement_end_token()) {
|
||||
// Only consume if this is an actual token.
|
||||
advance();
|
||||
} else if (lambda_ended) {
|
||||
lambda_ended = false; // Consume this "token".
|
||||
found = true;
|
||||
break;
|
||||
} else {
|
||||
if (!found) {
|
||||
lambda_ended = true; // Mark the lambda as done since we found something else to end the statement.
|
||||
found = true;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
found = true;
|
||||
advance();
|
||||
}
|
||||
if (!found && !is_at_end()) {
|
||||
push_error(vformat(R"(Expected end of statement after %s, found "%s" instead.)", p_context, current.get_name()));
|
||||
@ -1182,6 +1202,51 @@ GDScriptParser::EnumNode *GDScriptParser::parse_enum() {
|
||||
return enum_node;
|
||||
}
|
||||
|
||||
void GDScriptParser::parse_function_signature(FunctionNode *p_function, SuiteNode *p_body, const String &p_type) {
|
||||
if (!check(GDScriptTokenizer::Token::PARENTHESIS_CLOSE) && !is_at_end()) {
|
||||
bool default_used = false;
|
||||
do {
|
||||
if (check(GDScriptTokenizer::Token::PARENTHESIS_CLOSE)) {
|
||||
// Allow for trailing comma.
|
||||
break;
|
||||
}
|
||||
ParameterNode *parameter = parse_parameter();
|
||||
if (parameter == nullptr) {
|
||||
break;
|
||||
}
|
||||
if (parameter->default_value != nullptr) {
|
||||
default_used = true;
|
||||
} else {
|
||||
if (default_used) {
|
||||
push_error("Cannot have a mandatory parameters after optional parameters.");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (p_function->parameters_indices.has(parameter->identifier->name)) {
|
||||
push_error(vformat(R"(Parameter with name "%s" was already declared for this %s.)", parameter->identifier->name, p_type));
|
||||
} else {
|
||||
p_function->parameters_indices[parameter->identifier->name] = p_function->parameters.size();
|
||||
p_function->parameters.push_back(parameter);
|
||||
p_body->add_local(parameter, current_function);
|
||||
}
|
||||
} while (match(GDScriptTokenizer::Token::COMMA));
|
||||
}
|
||||
|
||||
pop_multiline();
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_CLOSE, vformat(R"*(Expected closing ")" after %s parameters.)*", p_type));
|
||||
|
||||
if (match(GDScriptTokenizer::Token::FORWARD_ARROW)) {
|
||||
make_completion_context(COMPLETION_TYPE_NAME_OR_VOID, p_function);
|
||||
p_function->return_type = parse_type(true);
|
||||
if (p_function->return_type == nullptr) {
|
||||
push_error(R"(Expected return type or "void" after "->".)");
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Improve token consumption so it synchronizes to a statement boundary. This way we can get into the function body with unrecognized tokens.
|
||||
consume(GDScriptTokenizer::Token::COLON, vformat(R"(Expected ":" after %s declaration.)", p_type));
|
||||
}
|
||||
|
||||
GDScriptParser::FunctionNode *GDScriptParser::parse_function() {
|
||||
bool _static = false;
|
||||
if (previous.type == GDScriptTokenizer::Token::STATIC) {
|
||||
@ -1205,55 +1270,13 @@ GDScriptParser::FunctionNode *GDScriptParser::parse_function() {
|
||||
function->identifier = parse_identifier();
|
||||
function->is_static = _static;
|
||||
|
||||
push_multiline(true);
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_OPEN, R"(Expected opening "(" after function name.)");
|
||||
|
||||
SuiteNode *body = alloc_node<SuiteNode>();
|
||||
SuiteNode *previous_suite = current_suite;
|
||||
current_suite = body;
|
||||
|
||||
if (!check(GDScriptTokenizer::Token::PARENTHESIS_CLOSE) && !is_at_end()) {
|
||||
bool default_used = false;
|
||||
do {
|
||||
if (check(GDScriptTokenizer::Token::PARENTHESIS_CLOSE)) {
|
||||
// Allow for trailing comma.
|
||||
break;
|
||||
}
|
||||
ParameterNode *parameter = parse_parameter();
|
||||
if (parameter == nullptr) {
|
||||
break;
|
||||
}
|
||||
if (parameter->default_value != nullptr) {
|
||||
default_used = true;
|
||||
} else {
|
||||
if (default_used) {
|
||||
push_error("Cannot have a mandatory parameters after optional parameters.");
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if (function->parameters_indices.has(parameter->identifier->name)) {
|
||||
push_error(vformat(R"(Parameter with name "%s" was already declared for this function.)", parameter->identifier->name));
|
||||
} else {
|
||||
function->parameters_indices[parameter->identifier->name] = function->parameters.size();
|
||||
function->parameters.push_back(parameter);
|
||||
body->add_local(parameter);
|
||||
}
|
||||
} while (match(GDScriptTokenizer::Token::COMMA));
|
||||
}
|
||||
|
||||
pop_multiline();
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_CLOSE, R"*(Expected closing ")" after function parameters.)*");
|
||||
|
||||
if (match(GDScriptTokenizer::Token::FORWARD_ARROW)) {
|
||||
make_completion_context(COMPLETION_TYPE_NAME_OR_VOID, function);
|
||||
function->return_type = parse_type(true);
|
||||
if (function->return_type == nullptr) {
|
||||
push_error(R"(Expected return type or "void" after "->".)");
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Improve token consumption so it synchronizes to a statement boundary. This way we can get into the function body with unrecognized tokens.
|
||||
consume(GDScriptTokenizer::Token::COLON, R"(Expected ":" after function declaration.)");
|
||||
push_multiline(true);
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_OPEN, R"(Expected opening "(" after function name.)");
|
||||
parse_function_signature(function, body, "function");
|
||||
|
||||
current_suite = previous_suite;
|
||||
function->body = parse_suite("function declaration", body);
|
||||
@ -1339,29 +1362,34 @@ bool GDScriptParser::register_annotation(const MethodInfo &p_info, uint32_t p_ta
|
||||
return true;
|
||||
}
|
||||
|
||||
GDScriptParser::SuiteNode *GDScriptParser::parse_suite(const String &p_context, SuiteNode *p_suite) {
|
||||
GDScriptParser::SuiteNode *GDScriptParser::parse_suite(const String &p_context, SuiteNode *p_suite, bool p_for_lambda) {
|
||||
SuiteNode *suite = p_suite != nullptr ? p_suite : alloc_node<SuiteNode>();
|
||||
suite->parent_block = current_suite;
|
||||
suite->parent_function = current_function;
|
||||
current_suite = suite;
|
||||
|
||||
bool multiline = false;
|
||||
|
||||
if (check(GDScriptTokenizer::Token::NEWLINE)) {
|
||||
if (match(GDScriptTokenizer::Token::NEWLINE)) {
|
||||
multiline = true;
|
||||
}
|
||||
|
||||
if (multiline) {
|
||||
consume(GDScriptTokenizer::Token::NEWLINE, vformat(R"(Expected newline after %s.)", p_context));
|
||||
|
||||
if (!consume(GDScriptTokenizer::Token::INDENT, vformat(R"(Expected indented block after %s.)", p_context))) {
|
||||
current_suite = suite->parent_block;
|
||||
return suite;
|
||||
}
|
||||
}
|
||||
|
||||
int error_count = 0;
|
||||
|
||||
do {
|
||||
Node *statement = parse_statement();
|
||||
if (statement == nullptr) {
|
||||
if (error_count++ > 100) {
|
||||
push_error("Too many statement errors.", suite);
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
suite->statements.push_back(statement);
|
||||
@ -1374,7 +1402,7 @@ GDScriptParser::SuiteNode *GDScriptParser::parse_suite(const String &p_context,
|
||||
if (local.type != SuiteNode::Local::UNDEFINED) {
|
||||
push_error(vformat(R"(There is already a %s named "%s" declared in this scope.)", local.get_name(), variable->identifier->name));
|
||||
}
|
||||
current_suite->add_local(variable);
|
||||
current_suite->add_local(variable, current_function);
|
||||
break;
|
||||
}
|
||||
case Node::CONSTANT: {
|
||||
@ -1389,19 +1417,29 @@ GDScriptParser::SuiteNode *GDScriptParser::parse_suite(const String &p_context,
|
||||
}
|
||||
push_error(vformat(R"(There is already a %s named "%s" declared in this scope.)", name, constant->identifier->name));
|
||||
}
|
||||
current_suite->add_local(constant);
|
||||
current_suite->add_local(constant, current_function);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
} while (multiline && !check(GDScriptTokenizer::Token::DEDENT) && !is_at_end());
|
||||
} while (multiline && !check(GDScriptTokenizer::Token::DEDENT) && !lambda_ended && !is_at_end());
|
||||
|
||||
if (multiline) {
|
||||
consume(GDScriptTokenizer::Token::DEDENT, vformat(R"(Missing unindent at the end of %s.)", p_context));
|
||||
if (!lambda_ended) {
|
||||
consume(GDScriptTokenizer::Token::DEDENT, vformat(R"(Missing unindent at the end of %s.)", p_context));
|
||||
|
||||
} else {
|
||||
match(GDScriptTokenizer::Token::DEDENT);
|
||||
}
|
||||
} else if (previous.type == GDScriptTokenizer::Token::SEMICOLON) {
|
||||
consume(GDScriptTokenizer::Token::NEWLINE, vformat(R"(Expected newline after ";" at the end of %s.)", p_context));
|
||||
}
|
||||
|
||||
if (p_for_lambda) {
|
||||
lambda_ended = true;
|
||||
}
|
||||
current_suite = suite->parent_block;
|
||||
return suite;
|
||||
}
|
||||
@ -1458,6 +1496,10 @@ GDScriptParser::Node *GDScriptParser::parse_statement() {
|
||||
push_error(R"(Constructor cannot return a value.)");
|
||||
}
|
||||
n_return->return_value = parse_expression(false);
|
||||
} else if (in_lambda && !is_statement_end_token()) {
|
||||
// Try to parse it anyway as this might not be the statement end in a lambda.
|
||||
// If this fails the expression will be nullptr, but that's the same as no return, so it's fine.
|
||||
n_return->return_value = parse_expression(false);
|
||||
}
|
||||
result = n_return;
|
||||
|
||||
@ -1486,10 +1528,18 @@ GDScriptParser::Node *GDScriptParser::parse_statement() {
|
||||
default: {
|
||||
// Expression statement.
|
||||
ExpressionNode *expression = parse_expression(true); // Allow assignment here.
|
||||
bool has_ended_lambda = false;
|
||||
if (expression == nullptr) {
|
||||
push_error(vformat(R"(Expected statement, found "%s" instead.)", previous.get_name()));
|
||||
if (in_lambda) {
|
||||
// If it's not a valid expression beginning, it might be the continuation of the outer expression where this lambda is.
|
||||
lambda_ended = true;
|
||||
has_ended_lambda = true;
|
||||
} else {
|
||||
push_error(vformat(R"(Expected statement, found "%s" instead.)", previous.get_name()));
|
||||
}
|
||||
}
|
||||
end_statement("expression");
|
||||
lambda_ended = lambda_ended || has_ended_lambda;
|
||||
result = expression;
|
||||
|
||||
#ifdef DEBUG_ENABLED
|
||||
@ -1513,7 +1563,7 @@ GDScriptParser::Node *GDScriptParser::parse_statement() {
|
||||
if (unreachable && result != nullptr) {
|
||||
current_suite->has_unreachable_code = true;
|
||||
if (current_function) {
|
||||
push_warning(result, GDScriptWarning::UNREACHABLE_CODE, current_function->identifier->name);
|
||||
push_warning(result, GDScriptWarning::UNREACHABLE_CODE, current_function->identifier ? current_function->identifier->name : "<anonymous lambda>");
|
||||
} else {
|
||||
// TODO: Properties setters and getters with unreachable code are not being warned
|
||||
}
|
||||
@ -1598,7 +1648,7 @@ GDScriptParser::ForNode *GDScriptParser::parse_for() {
|
||||
|
||||
SuiteNode *suite = alloc_node<SuiteNode>();
|
||||
if (n_for->variable) {
|
||||
suite->add_local(SuiteNode::Local(n_for->variable));
|
||||
suite->add_local(SuiteNode::Local(n_for->variable, current_function));
|
||||
}
|
||||
suite->parent_for = n_for;
|
||||
|
||||
@ -1753,7 +1803,7 @@ GDScriptParser::MatchBranchNode *GDScriptParser::parse_match_branch() {
|
||||
branch->patterns[0]->binds.get_key_list(&binds);
|
||||
|
||||
for (List<StringName>::Element *E = binds.front(); E != nullptr; E = E->next()) {
|
||||
SuiteNode::Local local(branch->patterns[0]->binds[E->get()]);
|
||||
SuiteNode::Local local(branch->patterns[0]->binds[E->get()], current_function);
|
||||
suite->add_local(local);
|
||||
}
|
||||
}
|
||||
@ -1953,7 +2003,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_precedence(Precedence p_pr
|
||||
// Completion can appear whenever an expression is expected.
|
||||
make_completion_context(COMPLETION_IDENTIFIER, nullptr);
|
||||
|
||||
GDScriptTokenizer::Token token = advance();
|
||||
GDScriptTokenizer::Token token = current;
|
||||
ParseFunction prefix_rule = get_rule(token.type)->prefix;
|
||||
|
||||
if (prefix_rule == nullptr) {
|
||||
@ -1961,6 +2011,8 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_precedence(Precedence p_pr
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
advance(); // Only consume the token if there's a valid rule.
|
||||
|
||||
ExpressionNode *previous_operand = (this->*prefix_rule)(nullptr, p_can_assign);
|
||||
|
||||
while (p_precedence <= get_rule(current.type)->precedence) {
|
||||
@ -2002,6 +2054,8 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_identifier(ExpressionNode
|
||||
|
||||
if (current_suite != nullptr && current_suite->has_local(identifier->name)) {
|
||||
const SuiteNode::Local &declaration = current_suite->get_local(identifier->name);
|
||||
|
||||
identifier->source_function = declaration.source_function;
|
||||
switch (declaration.type) {
|
||||
case SuiteNode::Local::CONSTANT:
|
||||
identifier->source = IdentifierNode::LOCAL_CONSTANT;
|
||||
@ -2055,6 +2109,9 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_self(ExpressionNode *p_pre
|
||||
if (current_function && current_function->is_static) {
|
||||
push_error(R"(Cannot use "self" inside a static function.)");
|
||||
}
|
||||
if (in_lambda) {
|
||||
push_error(R"(Cannot use "self" inside a lambda.)");
|
||||
}
|
||||
SelfNode *self = alloc_node<SelfNode>();
|
||||
self->current_class = current_class;
|
||||
return self;
|
||||
@ -2488,7 +2545,7 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_attribute(ExpressionNode *
|
||||
|
||||
if (for_completion) {
|
||||
bool is_builtin = false;
|
||||
if (p_previous_operand->type == Node::IDENTIFIER) {
|
||||
if (p_previous_operand && p_previous_operand->type == Node::IDENTIFIER) {
|
||||
const IdentifierNode *id = static_cast<const IdentifierNode *>(p_previous_operand);
|
||||
Variant::Type builtin_type = get_builtin_type(id->name);
|
||||
if (builtin_type < Variant::VARIANT_MAX) {
|
||||
@ -2675,6 +2732,65 @@ GDScriptParser::ExpressionNode *GDScriptParser::parse_preload(ExpressionNode *p_
|
||||
return preload;
|
||||
}
|
||||
|
||||
GDScriptParser::ExpressionNode *GDScriptParser::parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign) {
|
||||
LambdaNode *lambda = alloc_node<LambdaNode>();
|
||||
lambda->parent_function = current_function;
|
||||
FunctionNode *function = alloc_node<FunctionNode>();
|
||||
function->source_lambda = lambda;
|
||||
|
||||
function->is_static = current_function != nullptr ? current_function->is_static : false;
|
||||
|
||||
if (match(GDScriptTokenizer::Token::IDENTIFIER)) {
|
||||
function->identifier = parse_identifier();
|
||||
}
|
||||
|
||||
bool multiline_context = multiline_stack.back()->get();
|
||||
|
||||
// Reset the multiline stack since we don't want the multiline mode one in the lambda body.
|
||||
push_multiline(false);
|
||||
if (multiline_context) {
|
||||
tokenizer.push_expression_indented_block();
|
||||
}
|
||||
|
||||
push_multiline(true); // For the parameters.
|
||||
if (function->identifier) {
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_OPEN, R"(Expected opening "(" after lambda name.)");
|
||||
} else {
|
||||
consume(GDScriptTokenizer::Token::PARENTHESIS_OPEN, R"(Expected opening "(" after "func".)");
|
||||
}
|
||||
|
||||
FunctionNode *previous_function = current_function;
|
||||
current_function = function;
|
||||
|
||||
SuiteNode *body = alloc_node<SuiteNode>();
|
||||
SuiteNode *previous_suite = current_suite;
|
||||
current_suite = body;
|
||||
|
||||
parse_function_signature(function, body, "lambda");
|
||||
|
||||
current_suite = previous_suite;
|
||||
|
||||
bool previous_in_lambda = in_lambda;
|
||||
in_lambda = true;
|
||||
|
||||
function->body = parse_suite("lambda declaration", body, true);
|
||||
|
||||
pop_multiline();
|
||||
|
||||
if (multiline_context) {
|
||||
// If we're in multiline mode, we want to skip the spurious DEDENT and NEWLINE tokens.
|
||||
while (check(GDScriptTokenizer::Token::DEDENT) || check(GDScriptTokenizer::Token::INDENT) || check(GDScriptTokenizer::Token::NEWLINE)) {
|
||||
current = tokenizer.scan(); // Not advance() since we don't want to change the previous token.
|
||||
}
|
||||
tokenizer.pop_expression_indented_block();
|
||||
}
|
||||
|
||||
current_function = previous_function;
|
||||
in_lambda = previous_in_lambda;
|
||||
lambda->function = function;
|
||||
return lambda;
|
||||
}
|
||||
|
||||
GDScriptParser::ExpressionNode *GDScriptParser::parse_invalid_token(ExpressionNode *p_previous_operand, bool p_can_assign) {
|
||||
// Just for better error messages.
|
||||
GDScriptTokenizer::Token::Type invalid = previous.type;
|
||||
@ -3019,7 +3135,7 @@ GDScriptParser::ParseRule *GDScriptParser::get_rule(GDScriptTokenizer::Token::Ty
|
||||
{ nullptr, nullptr, PREC_NONE }, // CONST,
|
||||
{ nullptr, nullptr, PREC_NONE }, // ENUM,
|
||||
{ nullptr, nullptr, PREC_NONE }, // EXTENDS,
|
||||
{ nullptr, nullptr, PREC_NONE }, // FUNC,
|
||||
{ &GDScriptParser::parse_lambda, nullptr, PREC_NONE }, // FUNC,
|
||||
{ nullptr, &GDScriptParser::parse_binary_operator, PREC_CONTENT_TEST }, // IN,
|
||||
{ nullptr, &GDScriptParser::parse_binary_operator, PREC_TYPE_TEST }, // IS,
|
||||
{ nullptr, nullptr, PREC_NONE }, // NAMESPACE,
|
||||
@ -3755,6 +3871,10 @@ void GDScriptParser::TreePrinter::print_dictionary(DictionaryNode *p_dictionary)
|
||||
}
|
||||
|
||||
void GDScriptParser::TreePrinter::print_expression(ExpressionNode *p_expression) {
|
||||
if (p_expression == nullptr) {
|
||||
push_text("<invalid expression>");
|
||||
return;
|
||||
}
|
||||
switch (p_expression->type) {
|
||||
case Node::ARRAY:
|
||||
print_array(static_cast<ArrayNode *>(p_expression));
|
||||
@ -3783,6 +3903,9 @@ void GDScriptParser::TreePrinter::print_expression(ExpressionNode *p_expression)
|
||||
case Node::IDENTIFIER:
|
||||
print_identifier(static_cast<IdentifierNode *>(p_expression));
|
||||
break;
|
||||
case Node::LAMBDA:
|
||||
print_lambda(static_cast<LambdaNode *>(p_expression));
|
||||
break;
|
||||
case Node::LITERAL:
|
||||
print_literal(static_cast<LiteralNode *>(p_expression));
|
||||
break;
|
||||
@ -3842,12 +3965,17 @@ void GDScriptParser::TreePrinter::print_for(ForNode *p_for) {
|
||||
decrease_indent();
|
||||
}
|
||||
|
||||
void GDScriptParser::TreePrinter::print_function(FunctionNode *p_function) {
|
||||
void GDScriptParser::TreePrinter::print_function(FunctionNode *p_function, const String &p_context) {
|
||||
for (const List<AnnotationNode *>::Element *E = p_function->annotations.front(); E != nullptr; E = E->next()) {
|
||||
print_annotation(E->get());
|
||||
}
|
||||
push_text("Function ");
|
||||
print_identifier(p_function->identifier);
|
||||
push_text(p_context);
|
||||
push_text(" ");
|
||||
if (p_function->identifier) {
|
||||
print_identifier(p_function->identifier);
|
||||
} else {
|
||||
push_text("<anonymous>");
|
||||
}
|
||||
push_text("( ");
|
||||
for (int i = 0; i < p_function->parameters.size(); i++) {
|
||||
if (i > 0) {
|
||||
@ -3901,6 +4029,18 @@ void GDScriptParser::TreePrinter::print_if(IfNode *p_if, bool p_is_elif) {
|
||||
}
|
||||
}
|
||||
|
||||
void GDScriptParser::TreePrinter::print_lambda(LambdaNode *p_lambda) {
|
||||
print_function(p_lambda->function, "Lambda");
|
||||
push_text("| captures [ ");
|
||||
for (int i = 0; i < p_lambda->captures.size(); i++) {
|
||||
if (i > 0) {
|
||||
push_text(" , ");
|
||||
}
|
||||
push_text(p_lambda->captures[i]->name.operator String());
|
||||
}
|
||||
push_line(" ]");
|
||||
}
|
||||
|
||||
void GDScriptParser::TreePrinter::print_literal(LiteralNode *p_literal) {
|
||||
// Prefix for string types.
|
||||
switch (p_literal->value.get_type()) {
|
||||
|
||||
@ -76,6 +76,7 @@ public:
|
||||
struct GetNodeNode;
|
||||
struct IdentifierNode;
|
||||
struct IfNode;
|
||||
struct LambdaNode;
|
||||
struct LiteralNode;
|
||||
struct MatchNode;
|
||||
struct MatchBranchNode;
|
||||
@ -267,6 +268,7 @@ public:
|
||||
GET_NODE,
|
||||
IDENTIFIER,
|
||||
IF,
|
||||
LAMBDA,
|
||||
LITERAL,
|
||||
MATCH,
|
||||
MATCH_BRANCH,
|
||||
@ -728,6 +730,7 @@ public:
|
||||
bool is_coroutine = false;
|
||||
MultiplayerAPI::RPCMode rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
|
||||
MethodInfo info;
|
||||
LambdaNode *source_lambda = nullptr;
|
||||
#ifdef TOOLS_ENABLED
|
||||
Vector<Variant> default_arg_values;
|
||||
String doc_description;
|
||||
@ -771,6 +774,7 @@ public:
|
||||
VariableNode *variable_source;
|
||||
IdentifierNode *bind_source;
|
||||
};
|
||||
FunctionNode *source_function = nullptr;
|
||||
|
||||
int usages = 0; // Useful for binds/iterator variable.
|
||||
|
||||
@ -789,6 +793,21 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
struct LambdaNode : public ExpressionNode {
|
||||
FunctionNode *function = nullptr;
|
||||
FunctionNode *parent_function = nullptr;
|
||||
Vector<IdentifierNode *> captures;
|
||||
Map<StringName, int> captures_indices;
|
||||
|
||||
bool has_name() const {
|
||||
return function && function->identifier;
|
||||
}
|
||||
|
||||
LambdaNode() {
|
||||
type = LAMBDA;
|
||||
}
|
||||
};
|
||||
|
||||
struct LiteralNode : public ExpressionNode {
|
||||
Variant value;
|
||||
|
||||
@ -942,6 +961,7 @@ public:
|
||||
IdentifierNode *bind;
|
||||
};
|
||||
StringName name;
|
||||
FunctionNode *source_function = nullptr;
|
||||
|
||||
int start_line = 0, end_line = 0;
|
||||
int start_column = 0, end_column = 0;
|
||||
@ -951,10 +971,11 @@ public:
|
||||
String get_name() const;
|
||||
|
||||
Local() {}
|
||||
Local(ConstantNode *p_constant) {
|
||||
Local(ConstantNode *p_constant, FunctionNode *p_source_function) {
|
||||
type = CONSTANT;
|
||||
constant = p_constant;
|
||||
name = p_constant->identifier->name;
|
||||
source_function = p_source_function;
|
||||
|
||||
start_line = p_constant->start_line;
|
||||
end_line = p_constant->end_line;
|
||||
@ -963,10 +984,11 @@ public:
|
||||
leftmost_column = p_constant->leftmost_column;
|
||||
rightmost_column = p_constant->rightmost_column;
|
||||
}
|
||||
Local(VariableNode *p_variable) {
|
||||
Local(VariableNode *p_variable, FunctionNode *p_source_function) {
|
||||
type = VARIABLE;
|
||||
variable = p_variable;
|
||||
name = p_variable->identifier->name;
|
||||
source_function = p_source_function;
|
||||
|
||||
start_line = p_variable->start_line;
|
||||
end_line = p_variable->end_line;
|
||||
@ -975,10 +997,11 @@ public:
|
||||
leftmost_column = p_variable->leftmost_column;
|
||||
rightmost_column = p_variable->rightmost_column;
|
||||
}
|
||||
Local(ParameterNode *p_parameter) {
|
||||
Local(ParameterNode *p_parameter, FunctionNode *p_source_function) {
|
||||
type = PARAMETER;
|
||||
parameter = p_parameter;
|
||||
name = p_parameter->identifier->name;
|
||||
source_function = p_source_function;
|
||||
|
||||
start_line = p_parameter->start_line;
|
||||
end_line = p_parameter->end_line;
|
||||
@ -987,10 +1010,11 @@ public:
|
||||
leftmost_column = p_parameter->leftmost_column;
|
||||
rightmost_column = p_parameter->rightmost_column;
|
||||
}
|
||||
Local(IdentifierNode *p_identifier) {
|
||||
Local(IdentifierNode *p_identifier, FunctionNode *p_source_function) {
|
||||
type = FOR_VARIABLE;
|
||||
bind = p_identifier;
|
||||
name = p_identifier->name;
|
||||
source_function = p_source_function;
|
||||
|
||||
start_line = p_identifier->start_line;
|
||||
end_line = p_identifier->end_line;
|
||||
@ -1015,9 +1039,9 @@ public:
|
||||
bool has_local(const StringName &p_name) const;
|
||||
const Local &get_local(const StringName &p_name) const;
|
||||
template <class T>
|
||||
void add_local(T *p_local) {
|
||||
void add_local(T *p_local, FunctionNode *p_source_function) {
|
||||
locals_indices[p_local->identifier->name] = locals.size();
|
||||
locals.push_back(Local(p_local));
|
||||
locals.push_back(Local(p_local, p_source_function));
|
||||
}
|
||||
void add_local(const Local &p_local) {
|
||||
locals_indices[p_local.name] = locals.size();
|
||||
@ -1191,6 +1215,8 @@ private:
|
||||
CompletionCall completion_call;
|
||||
List<CompletionCall> completion_call_stack;
|
||||
bool passed_cursor = false;
|
||||
bool in_lambda = false;
|
||||
bool lambda_ended = false; // Marker for when a lambda ends, to apply an end of statement if needed.
|
||||
|
||||
typedef bool (GDScriptParser::*AnnotationAction)(const AnnotationNode *p_annotation, Node *p_target);
|
||||
struct AnnotationInfo {
|
||||
@ -1278,10 +1304,11 @@ private:
|
||||
|
||||
GDScriptTokenizer::Token advance();
|
||||
bool match(GDScriptTokenizer::Token::Type p_token_type);
|
||||
bool check(GDScriptTokenizer::Token::Type p_token_type);
|
||||
bool check(GDScriptTokenizer::Token::Type p_token_type) const;
|
||||
bool consume(GDScriptTokenizer::Token::Type p_token_type, const String &p_error_message);
|
||||
bool is_at_end();
|
||||
bool is_statement_end();
|
||||
bool is_at_end() const;
|
||||
bool is_statement_end_token() const;
|
||||
bool is_statement_end() const;
|
||||
void end_statement(const String &p_context);
|
||||
void synchronize();
|
||||
void push_multiline(bool p_state);
|
||||
@ -1299,7 +1326,8 @@ private:
|
||||
EnumNode *parse_enum();
|
||||
ParameterNode *parse_parameter();
|
||||
FunctionNode *parse_function();
|
||||
SuiteNode *parse_suite(const String &p_context, SuiteNode *p_suite = nullptr);
|
||||
void parse_function_signature(FunctionNode *p_function, SuiteNode *p_body, const String &p_type);
|
||||
SuiteNode *parse_suite(const String &p_context, SuiteNode *p_suite = nullptr, bool p_for_lambda = false);
|
||||
// Annotations
|
||||
AnnotationNode *parse_annotation(uint32_t p_valid_targets);
|
||||
bool register_annotation(const MethodInfo &p_info, uint32_t p_target_kinds, AnnotationAction p_apply, int p_optional_arguments = 0, bool p_is_vararg = false);
|
||||
@ -1354,6 +1382,7 @@ private:
|
||||
ExpressionNode *parse_await(ExpressionNode *p_previous_operand, bool p_can_assign);
|
||||
ExpressionNode *parse_attribute(ExpressionNode *p_previous_operand, bool p_can_assign);
|
||||
ExpressionNode *parse_subscript(ExpressionNode *p_previous_operand, bool p_can_assign);
|
||||
ExpressionNode *parse_lambda(ExpressionNode *p_previous_operand, bool p_can_assign);
|
||||
ExpressionNode *parse_invalid_token(ExpressionNode *p_previous_operand, bool p_can_assign);
|
||||
TypeNode *parse_type(bool p_allow_void = false);
|
||||
#ifdef TOOLS_ENABLED
|
||||
@ -1415,10 +1444,11 @@ public:
|
||||
void print_expression(ExpressionNode *p_expression);
|
||||
void print_enum(EnumNode *p_enum);
|
||||
void print_for(ForNode *p_for);
|
||||
void print_function(FunctionNode *p_function);
|
||||
void print_function(FunctionNode *p_function, const String &p_context = "Function");
|
||||
void print_get_node(GetNodeNode *p_get_node);
|
||||
void print_if(IfNode *p_if, bool p_is_elif = false);
|
||||
void print_identifier(IdentifierNode *p_identifier);
|
||||
void print_lambda(LambdaNode *p_lambda);
|
||||
void print_literal(LiteralNode *p_literal);
|
||||
void print_match(MatchNode *p_match);
|
||||
void print_match_branch(MatchBranchNode *p_match_branch);
|
||||
|
||||
@ -242,6 +242,16 @@ void GDScriptTokenizer::set_multiline_mode(bool p_state) {
|
||||
multiline_mode = p_state;
|
||||
}
|
||||
|
||||
void GDScriptTokenizer::push_expression_indented_block() {
|
||||
indent_stack_stack.push_back(indent_stack);
|
||||
}
|
||||
|
||||
void GDScriptTokenizer::pop_expression_indented_block() {
|
||||
ERR_FAIL_COND(indent_stack_stack.size() == 0);
|
||||
indent_stack = indent_stack_stack.back()->get();
|
||||
indent_stack_stack.pop_back();
|
||||
}
|
||||
|
||||
int GDScriptTokenizer::get_cursor_line() const {
|
||||
return cursor_line;
|
||||
}
|
||||
|
||||
@ -217,6 +217,7 @@ private:
|
||||
Token last_newline;
|
||||
int pending_indents = 0;
|
||||
List<int> indent_stack;
|
||||
List<List<int>> indent_stack_stack; // For lambdas, which require manipulating the indentation point.
|
||||
List<char32_t> paren_stack;
|
||||
char32_t indent_char = '\0';
|
||||
int position = 0;
|
||||
@ -263,6 +264,8 @@ public:
|
||||
void set_multiline_mode(bool p_state);
|
||||
bool is_past_cursor() const;
|
||||
static String get_token_name(Token::Type p_token_type);
|
||||
void push_expression_indented_block(); // For lambdas, or blocks inside expressions.
|
||||
void pop_expression_indented_block(); // For lambdas, or blocks inside expressions.
|
||||
|
||||
GDScriptTokenizer();
|
||||
};
|
||||
|
||||
@ -33,6 +33,7 @@
|
||||
#include "core/core_string_names.h"
|
||||
#include "core/os/os.h"
|
||||
#include "gdscript.h"
|
||||
#include "gdscript_lambda_callable.h"
|
||||
|
||||
Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_instance, Variant *p_stack, String &r_error) const {
|
||||
int address = p_address & ADDR_MASK;
|
||||
@ -232,6 +233,7 @@ String GDScriptFunction::_get_call_error(const Callable::CallError &p_err, const
|
||||
&&OPCODE_CALL_PTRCALL_PACKED_COLOR_ARRAY, \
|
||||
&&OPCODE_AWAIT, \
|
||||
&&OPCODE_AWAIT_RESUME, \
|
||||
&&OPCODE_CREATE_LAMBDA, \
|
||||
&&OPCODE_JUMP, \
|
||||
&&OPCODE_JUMP_IF, \
|
||||
&&OPCODE_JUMP_IF_NOT, \
|
||||
@ -1452,13 +1454,17 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
|
||||
if (err.error != Callable::CallError::CALL_OK) {
|
||||
String methodstr = *methodname;
|
||||
String basestr = _get_var_type(base);
|
||||
bool is_callable = false;
|
||||
|
||||
if (methodstr == "call") {
|
||||
if (argc >= 1) {
|
||||
if (argc >= 1 && base->get_type() != Variant::CALLABLE) {
|
||||
methodstr = String(*argptrs[0]) + " (via call)";
|
||||
if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
|
||||
err.argument += 1;
|
||||
}
|
||||
} else {
|
||||
methodstr = base->operator String() + " (Callable)";
|
||||
is_callable = true;
|
||||
}
|
||||
} else if (methodstr == "free") {
|
||||
if (err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
|
||||
@ -1478,7 +1484,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
|
||||
}
|
||||
}
|
||||
}
|
||||
err_text = _get_call_error(err, "function '" + methodstr + "' in base '" + basestr + "'", (const Variant **)argptrs);
|
||||
err_text = _get_call_error(err, "function '" + methodstr + (is_callable ? "" : "' in base '" + basestr) + "'", (const Variant **)argptrs);
|
||||
OPCODE_BREAK;
|
||||
}
|
||||
#endif
|
||||
@ -2057,6 +2063,34 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
|
||||
}
|
||||
DISPATCH_OPCODE;
|
||||
|
||||
OPCODE(OPCODE_CREATE_LAMBDA) {
|
||||
CHECK_SPACE(2 + instr_arg_count);
|
||||
|
||||
ip += instr_arg_count;
|
||||
|
||||
int captures_count = _code_ptr[ip + 1];
|
||||
GD_ERR_BREAK(captures_count < 0);
|
||||
|
||||
int lambda_index = _code_ptr[ip + 2];
|
||||
GD_ERR_BREAK(lambda_index < 0 || lambda_index >= _lambdas_count);
|
||||
GDScriptFunction *lambda = _lambdas_ptr[lambda_index];
|
||||
|
||||
Vector<Variant> captures;
|
||||
captures.resize(captures_count);
|
||||
for (int i = 0; i < captures_count; i++) {
|
||||
GET_INSTRUCTION_ARG(arg, i);
|
||||
captures.write[i] = *arg;
|
||||
}
|
||||
|
||||
GDScriptLambdaCallable *callable = memnew(GDScriptLambdaCallable(Ref<GDScript>(script), lambda, captures));
|
||||
|
||||
GET_INSTRUCTION_ARG(result, captures_count);
|
||||
*result = Callable(callable);
|
||||
|
||||
ip += 3;
|
||||
}
|
||||
DISPATCH_OPCODE;
|
||||
|
||||
OPCODE(OPCODE_JUMP) {
|
||||
CHECK_SPACE(2);
|
||||
int to = _code_ptr[ip + 1];
|
||||
|
||||
@ -66,7 +66,7 @@ static void test_tokenizer(const String &p_code, const Vector<String> &p_lines)
|
||||
StringBuilder token;
|
||||
token += " --> "; // Padding for line number.
|
||||
|
||||
for (int l = current.start_line; l <= current.end_line; l++) {
|
||||
for (int l = current.start_line; l <= current.end_line && l <= p_lines.size(); l++) {
|
||||
print_line(vformat("%04d %s", l, p_lines[l - 1]).replace("\t", tab));
|
||||
}
|
||||
|
||||
@ -118,6 +118,18 @@ static void test_parser(const String &p_code, const String &p_script_path, const
|
||||
print_line(vformat("%02d:%02d: %s", error.line, error.column, error.message));
|
||||
}
|
||||
}
|
||||
|
||||
GDScriptAnalyzer analyzer(&parser);
|
||||
analyzer.analyze();
|
||||
|
||||
if (err != OK) {
|
||||
const List<GDScriptParser::ParserError> &errors = parser.get_errors();
|
||||
for (const List<GDScriptParser::ParserError>::Element *E = errors.front(); E != nullptr; E = E->next()) {
|
||||
const GDScriptParser::ParserError &error = E->get();
|
||||
print_line(vformat("%02d:%02d: %s", error.line, error.column, error.message));
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef TOOLS_ENABLED
|
||||
GDScriptParser::TreePrinter printer;
|
||||
printer.print_tree(parser);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user