godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/modules/gdscript/gdscript_function.cpp

2395 lines
64 KiB
C++
Raw Normal View History

Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/*************************************************************************/
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
/* gdscript_function.cpp */
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
/* */
/* 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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
#include "gdscript_function.h"
Add a bunch of missing Godot headers in own files
2017-03-05 14:47:28 +00:00
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/os/os.h"
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
#include "gdscript.h"
#include "gdscript_functions.h"
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
#ifdef DEBUG_ENABLED
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 22:33:38 +00:00
#include "core/string/string_builder.h"
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
#endif
GDScript: Remove self static reference and create one on calls This is needed because of the new changes to Variant. The reference counter is increased by adding it to a Variant, which means no GDScript will be freed (or will be double freed if manually freed somewhere).
2020-02-19 12:15:16 +00:00
Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_instance, GDScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int address = p_address & ADDR_MASK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//sequential table (jump table generated by compiler)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch ((p_address & ADDR_TYPE_MASK) >> ADDR_BITS) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
case ADDR_TYPE_SELF: {
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Implement Linux-style likely()/unlikely() macros This implement branch prediction macros likely() and unlikely() like in Linux. When using these macros please ensure that when you use them the condition in the branch really is very, very likely or unlikely. Think 90+% of the time. Primarily useful for error checking. (And I implement these macros for all our error checking macros now) See this article for more information: https://kernelnewbies.org/FAQ/LikelyUnlikely There are more places where these macros may make sense in renderer and physics engine. Placing them will come in another commit down the line.
2017-09-20 09:04:50 +00:00
if (unlikely(!p_instance)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_error = "Cannot access self without instance.";
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
return nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return &self;
} break;
case ADDR_TYPE_CLASS: {
GDScript: Remove self static reference and create one on calls This is needed because of the new changes to Variant. The reference counter is increased by adding it to a Variant, which means no GDScript will be freed (or will be double freed if manually freed somewhere).
2020-02-19 12:15:16 +00:00
return &static_ref;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} break;
case ADDR_TYPE_MEMBER: {
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Implement Linux-style likely()/unlikely() macros This implement branch prediction macros likely() and unlikely() like in Linux. When using these macros please ensure that when you use them the condition in the branch really is very, very likely or unlikely. Think 90+% of the time. Primarily useful for error checking. (And I implement these macros for all our error checking macros now) See this article for more information: https://kernelnewbies.org/FAQ/LikelyUnlikely There are more places where these macros may make sense in renderer and physics engine. Placing them will come in another commit down the line.
2017-09-20 09:04:50 +00:00
if (unlikely(!p_instance)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_error = "Cannot access member without instance.";
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
return nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
//member indexing is O(1)
Reduce unnecessary COW on Vector by make writing explicit This commit makes operator[] on Vector const and adds a write proxy to it. From now on writes to Vectors need to happen through the .write proxy. So for instance: Vector<int> vec; vec.push_back(10); std::cout << vec[0] << std::endl; vec.write[0] = 20; Failing to use the .write proxy will cause a compilation error. In addition COWable datatypes can now embed a CowData pointer to their data. This means that String, CharString, and VMap no longer use or derive from Vector. _ALWAYS_INLINE_ and _FORCE_INLINE_ are now equivalent for debug and non-debug builds. This is a lot faster for Vector in the editor and while running tests. The reason why this difference used to exist is because force-inlined methods used to give a bad debugging experience. After extensive testing with modern compilers this is no longer the case.
2018-07-25 01:11:03 +00:00
return &p_instance->members.write[address];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} break;
case ADDR_TYPE_CLASS_CONSTANT: {
//todo change to index!
Fix constant access in base class through subclass instance Fixes as issue where a subclass calls a base class method that tries to access a constant from the script. The original code went through every ower class, and for each owner, went through its inheritance tree. This seems like the wrong order, the modified code goes to each base class, and for each base class goes through the owner tree. This is more in line with what the parser does, as the current impelemtation allows an access that the parser does not support. This change should not negatively affect existing code due to the way the parser works
2020-01-16 22:12:45 +00:00
GDScript *s = p_script;
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_INDEX_V(address, _global_names_count, nullptr);
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
const StringName *sn = &_global_names_ptr[address];
Fix constant access in base class through subclass instance Fixes as issue where a subclass calls a base class method that tries to access a constant from the script. The original code went through every ower class, and for each owner, went through its inheritance tree. This seems like the wrong order, the modified code goes to each base class, and for each base class goes through the owner tree. This is more in line with what the parser does, as the current impelemtation allows an access that the parser does not support. This change should not negatively affect existing code due to the way the parser works
2020-01-16 22:12:45 +00:00
while (s) {
GDScript *o = s;
while (o) {
Map<StringName, Variant>::Element *E = o->constants.find(*sn);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (E) {
return &E->get();
}
Fix constant access in base class through subclass instance Fixes as issue where a subclass calls a base class method that tries to access a constant from the script. The original code went through every ower class, and for each owner, went through its inheritance tree. This seems like the wrong order, the modified code goes to each base class, and for each base class goes through the owner tree. This is more in line with what the parser does, as the current impelemtation allows an access that the parser does not support. This change should not negatively affect existing code due to the way the parser works
2020-01-16 22:12:45 +00:00
o = o->_owner;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix constant access in base class through subclass instance Fixes as issue where a subclass calls a base class method that tries to access a constant from the script. The original code went through every ower class, and for each owner, went through its inheritance tree. This seems like the wrong order, the modified code goes to each base class, and for each base class goes through the owner tree. This is more in line with what the parser does, as the current impelemtation allows an access that the parser does not support. This change should not negatively affect existing code due to the way the parser works
2020-01-16 22:12:45 +00:00
s = s->_base;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_V_MSG(nullptr, "GDScriptCompiler bug.");
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} break;
case ADDR_TYPE_LOCAL_CONSTANT: {
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_INDEX_V(address, _constant_count, nullptr);
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return &_constants_ptr[address];
} break;
case ADDR_TYPE_STACK:
case ADDR_TYPE_STACK_VARIABLE: {
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_INDEX_V(address, _stack_size, nullptr);
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return &p_stack[address];
} break;
case ADDR_TYPE_GLOBAL: {
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_INDEX_V(address, GDScriptLanguage::get_singleton()->get_global_array_size(), nullptr);
Remove several checks on DEBUG_RELEASE These errors shouldn't be possible on a tested game. Remove the checks on release. Shaves about 10% off of tight loops.
2017-09-23 18:58:57 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return &GDScriptLanguage::get_singleton()->get_global_array()[address];
} break;
Enable autoload in editor - Tool scripts will be executed and can be accessed by plugins. - Other script languages can implement add/remove_named_global_constant to make use of this functionality.
2018-05-01 14:06:23 +00:00
#ifdef TOOLS_ENABLED
case ADDR_TYPE_NAMED_GLOBAL: {
#ifdef DEBUG_ENABLED
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
ERR_FAIL_INDEX_V(address, _global_names_count, nullptr);
Enable autoload in editor - Tool scripts will be executed and can be accessed by plugins. - Other script languages can implement add/remove_named_global_constant to make use of this functionality.
2018-05-01 14:06:23 +00:00
#endif
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
StringName id = _global_names_ptr[address];
Enable autoload in editor - Tool scripts will be executed and can be accessed by plugins. - Other script languages can implement add/remove_named_global_constant to make use of this functionality.
2018-05-01 14:06:23 +00:00
if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(id)) {
return (Variant *)&GDScriptLanguage::get_singleton()->get_named_globals_map()[id];
} else {
r_error = "Autoload singleton '" + String(id) + "' has been removed.";
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
return nullptr;
Enable autoload in editor - Tool scripts will be executed and can be accessed by plugins. - Other script languages can implement add/remove_named_global_constant to make use of this functionality.
2018-05-01 14:06:23 +00:00
}
} break;
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
case ADDR_TYPE_NIL: {
return &nil;
} break;
}
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_V_MSG(nullptr, "Bad code! (unknown addressing mode).");
return nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix warnings on release builds (not DEBUG_ENABLED) Fixes the following Clang 5 warnings: ``` modules/bmp/image_loader_bmp.cpp:46:60: warning: comparison of unsigned expression < 0 is always false [-Wtautological-compare] modules/bmp/image_loader_bmp.cpp:48:61: warning: comparison of unsigned expression < 0 is always false [-Wtautological-compare] drivers/png/image_loader_png.cpp:231:20: warning: comparison of unsigned expression >= 0 is always true [-Wtautological-compare] scene/gui/graph_edit.cpp:1045:8: warning: comparison of constant 0 with expression of type 'bool' is always false [-Wtautological-constant-out-of-range-compare] core/class_db.cpp:812:13: warning: unused variable 'check' [-Wunused-variable] core/io/file_access_pack.cpp:172:11: warning: unused variable 'ver_rev' [-Wunused-variable] core/math/bsp_tree.cpp:195:13: warning: unused variable 'plane' [-Wunused-variable] core/math/bsp_tree.cpp:168:6: warning: unused variable 'plane_count' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:685:10: warning: unused variable 'ok' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:706:10: warning: unused variable 'ok' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:755:19: warning: unused variable 'var_type' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:1306:12: warning: unused variable 'err' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:158:15: warning: unused function '_get_var_type' [-Wunused-function] modules/gdscript/gdscript_parser.cpp:750:20: warning: unused variable 'lv' [-Wunused-variable] modules/gdscript/gdscript_parser.cpp:59:15: warning: unused function '_find_function_name' [-Wunused-function] scene/main/node.cpp:2489:13: warning: unused function '_Node_debug_sn' [-Wunused-function] ```
2018-10-03 14:13:34 +00:00
#ifdef DEBUG_ENABLED
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
static String _get_var_type(const Variant *p_var) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String basestr;
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
if (p_var->get_type() == Variant::OBJECT) {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
bool was_freed;
Object *bobj = p_var->get_validated_object_with_check(was_freed);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!bobj) {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
if (was_freed) {
basestr = "null instance";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
basestr = "previously freed";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
} else {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (bobj->get_script_instance()) {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
basestr = bobj->get_class() + " (" + bobj->get_script_instance()->get_script()->get_path().get_file() + ")";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
} else {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
basestr = bobj->get_class();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
} else {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
basestr = Variant::get_type_name(p_var->get_type());
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
return basestr;
}
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
#endif // DEBUG_ENABLED
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
String GDScriptFunction::_get_call_error(const Callable::CallError &p_err, const String &p_where, const Variant **argptrs) const {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
String err_text;
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (p_err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
int errorarg = p_err.argument;
// Handle the Object to Object case separately as we don't have further class details.
#ifdef DEBUG_ENABLED
if (p_err.expected == Variant::OBJECT && argptrs[errorarg]->get_type() == p_err.expected) {
err_text = "Invalid type in " + p_where + ". The Object-derived class of argument " + itos(errorarg + 1) + " (" + _get_var_type(argptrs[errorarg]) + ") is not a subclass of the expected argument class.";
} else
#endif // DEBUG_ENABLED
{
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
err_text = "Invalid type in " + p_where + ". Cannot convert argument " + itos(errorarg + 1) + " from " + Variant::get_type_name(argptrs[errorarg]->get_type()) + " to " + Variant::get_type_name(Variant::Type(p_err.expected)) + ".";
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
} else if (p_err.error == Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
} else if (p_err.error == Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
} else if (p_err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
err_text = "Invalid call. Nonexistent " + p_where + ".";
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
} else if (p_err.error == Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
GDScript: Improve error on Object to Object invalid argument calls Fixes #27804.
2019-06-18 09:27:43 +00:00
err_text = "Attempt to call " + p_where + " on a null instance.";
} else {
err_text = "Bug, call error: #" + itos(p_err.error);
}
return err_text;
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
#if defined(__GNUC__)
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
#define OPCODES_TABLE \
static const void *switch_table_ops[] = { \
&&OPCODE_OPERATOR, \
&&OPCODE_EXTENDS_TEST, \
GDScript: Allow `is` operator to test built-in types
2018-08-26 16:31:23 +00:00
&&OPCODE_IS_BUILTIN, \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
&&OPCODE_SET, \
&&OPCODE_GET, \
&&OPCODE_SET_NAMED, \
&&OPCODE_GET_NAMED, \
&&OPCODE_SET_MEMBER, \
&&OPCODE_GET_MEMBER, \
&&OPCODE_ASSIGN, \
&&OPCODE_ASSIGN_TRUE, \
&&OPCODE_ASSIGN_FALSE, \
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
&&OPCODE_ASSIGN_TYPED_BUILTIN, \
&&OPCODE_ASSIGN_TYPED_NATIVE, \
&&OPCODE_ASSIGN_TYPED_SCRIPT, \
&&OPCODE_CAST_TO_BUILTIN, \
&&OPCODE_CAST_TO_NATIVE, \
&&OPCODE_CAST_TO_SCRIPT, \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
&&OPCODE_CONSTRUCT, \
&&OPCODE_CONSTRUCT_ARRAY, \
&&OPCODE_CONSTRUCT_DICTIONARY, \
&&OPCODE_CALL, \
&&OPCODE_CALL_RETURN, \
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
&&OPCODE_CALL_ASYNC, \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
&&OPCODE_CALL_BUILT_IN, \
&&OPCODE_CALL_SELF_BASE, \
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
&&OPCODE_AWAIT, \
&&OPCODE_AWAIT_RESUME, \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
&&OPCODE_JUMP, \
&&OPCODE_JUMP_IF, \
&&OPCODE_JUMP_IF_NOT, \
&&OPCODE_JUMP_TO_DEF_ARGUMENT, \
&&OPCODE_RETURN, \
&&OPCODE_ITERATE_BEGIN, \
&&OPCODE_ITERATE, \
&&OPCODE_ASSERT, \
&&OPCODE_BREAKPOINT, \
&&OPCODE_LINE, \
&&OPCODE_END \
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
}; \
static_assert((sizeof(switch_table_ops) / sizeof(switch_table_ops[0]) == (OPCODE_END + 1)), "Opcodes in jump table aren't the same as opcodes in enum.");
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
#define OPCODE(m_op) \
m_op:
#define OPCODE_WHILE(m_test)
#define OPCODES_END \
OPSEXIT:
#define OPCODES_OUT \
OPSOUT:
#define DISPATCH_OPCODE goto *switch_table_ops[_code_ptr[ip]]
#define OPCODE_SWITCH(m_test) DISPATCH_OPCODE;
#define OPCODE_BREAK goto OPSEXIT
#define OPCODE_OUT goto OPSOUT
#else
#define OPCODES_TABLE
#define OPCODE(m_op) case m_op:
#define OPCODE_WHILE(m_test) while (m_test)
#define OPCODES_END
#define OPCODES_OUT
#define DISPATCH_OPCODE continue
#define OPCODE_SWITCH(m_test) switch (m_test)
#define OPCODE_BREAK break
#define OPCODE_OUT break
#endif
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Callable::CallError &r_err, CallState *p_state) {
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODES_TABLE;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!_code_ptr) {
return Variant();
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_err.error = Callable::CallError::CALL_OK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant self;
GDScript: Remove self static reference and create one on calls This is needed because of the new changes to Variant. The reference counter is increased by adding it to a Variant, which means no GDScript will be freed (or will be double freed if manually freed somewhere).
2020-02-19 12:15:16 +00:00
Variant static_ref;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant retvalue;
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
Variant *stack = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant **call_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int defarg = 0;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Style: Apply new clang-format 5.0 style to all files
2017-12-06 20:36:34 +00:00
//GDScriptLanguage::get_singleton()->calls++;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
uint32_t alloca_size = 0;
Fix crash on signal/resume to dangling target Fixes #22443.
2018-10-17 18:36:47 +00:00
GDScript *script;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int ip = 0;
int line = _initial_line;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (p_state) {
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
//use existing (supplied) state (awaited)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
stack = (Variant *)p_state->stack.ptr();
Fix random crashes when using yield()
2017-03-21 01:17:17 +00:00
call_args = (Variant **)&p_state->stack.ptr()[sizeof(Variant) * p_state->stack_size]; //ptr() to avoid bounds check
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
line = p_state->line;
ip = p_state->ip;
alloca_size = p_state->stack.size();
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
script = p_state->script;
p_instance = p_state->instance;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
defarg = p_state->defarg;
self = p_state->self;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_argcount != _argument_count) {
if (p_argcount > _argument_count) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_err.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_err.argument = _argument_count;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return Variant();
} else if (p_argcount < _argument_count - _default_arg_count) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_err.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_err.argument = _argument_count - _default_arg_count;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return Variant();
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
defarg = _argument_count - p_argcount;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
alloca_size = sizeof(Variant *) * _call_size + sizeof(Variant) * _stack_size;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (alloca_size) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
uint8_t *aptr = (uint8_t *)alloca(alloca_size);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (_stack_size) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
stack = (Variant *)aptr;
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
for (int i = 0; i < p_argcount; i++) {
if (!argument_types[i].has_type) {
memnew_placement(&stack[i], Variant(*p_args[i]));
continue;
}
Revert "Forbid implicit type conversion in GDScript"
2019-03-04 11:25:59 +00:00
if (!argument_types[i].is_type(*p_args[i], true)) {
Revert "Allow parameters passed to GDScript functions to be nulled" This reverts commit f0efc7521e7302e60ebaab31a42fafd3ea2bda68. Fixes #37312.
2020-03-26 16:02:28 +00:00
r_err.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_err.argument = i;
r_err.expected = argument_types[i].kind == GDScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT;
return Variant();
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
}
Revert "Forbid implicit type conversion in GDScript"
2019-03-04 11:25:59 +00:00
if (argument_types[i].kind == GDScriptDataType::BUILTIN) {
Variant arg = Variant::construct(argument_types[i].builtin_type, &p_args[i], 1, r_err);
memnew_placement(&stack[i], Variant(arg));
} else {
memnew_placement(&stack[i], Variant(*p_args[i]));
}
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
}
for (int i = p_argcount; i < _stack_size; i++) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
memnew_placement(&stack[i], Variant);
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
stack = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
if (_call_size) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
call_args = (Variant **)&aptr[sizeof(Variant) * _stack_size];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
call_args = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
} else {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
stack = nullptr;
call_args = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
if (p_instance) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_instance->base_ref && static_cast<Reference *>(p_instance->owner)->is_referenced()) {
self = REF(static_cast<Reference *>(p_instance->owner));
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
self = p_instance->owner;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix crash on signal/resume to dangling target Fixes #22443.
2018-10-17 18:36:47 +00:00
script = p_instance->script.ptr();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Fix crash on signal/resume to dangling target
2018-11-25 11:38:12 +00:00
script = _script;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
Actually set GDScript static reference
2020-05-29 13:58:46 +00:00
static_ref = script;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String err_text;
#ifdef DEBUG_ENABLED
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (EngineDebugger::is_active()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
#define GD_ERR_BREAK(m_cond) \
{ \
if (unlikely(m_cond)) { \
_err_print_error(FUNCTION_STR, __FILE__, __LINE__, "Condition ' " _STR(m_cond) " ' is true. Breaking..:"); \
OPCODE_BREAK; \
Remove ERR_EXPLAIN macros and the scaffolding they needed.
2019-11-11 09:38:15 +00:00
} \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define CHECK_SPACE(m_space) \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
GD_ERR_BREAK((ip + m_space) > _code_size)
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
GDScript: Remove self static reference and create one on calls This is needed because of the new changes to Variant. The reference counter is increased by adding it to a Variant, which means no GDScript will be freed (or will be double freed if manually freed somewhere).
2020-02-19 12:15:16 +00:00
#define GET_VARIANT_PTR(m_v, m_code_ofs) \
Variant *m_v; \
m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, script, self, static_ref, stack, err_text); \
if (unlikely(!m_v)) \
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#else
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#define GD_ERR_BREAK(m_cond)
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#define CHECK_SPACE(m_space)
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
#define GET_VARIANT_PTR(m_v, m_code_ofs) \
Variant *m_v; \
GDScript: Remove self static reference and create one on calls This is needed because of the new changes to Variant. The reference counter is increased by adding it to a Variant, which means no GDScript will be freed (or will be double freed if manually freed somewhere).
2020-02-19 12:15:16 +00:00
m_v = _get_variant(_code_ptr[ip + m_code_ofs], p_instance, script, self, static_ref, stack, err_text);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
#ifdef DEBUG_ENABLED
Fix use of unitialized variables The second in my quest to make Godot 3.x compile with -Werror on GCC7
2017-09-01 20:33:39 +00:00
uint64_t function_start_time = 0;
uint64_t function_call_time = 0;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (GDScriptLanguage::get_singleton()->profiling) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
function_start_time = OS::get_singleton()->get_ticks_usec();
function_call_time = 0;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
profile.call_count++;
profile.frame_call_count++;
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool exit_ok = false;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
bool awaited = false;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_WHILE(ip < _code_size) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int last_opcode = _code_ptr[ip];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#else
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_WHILE(true) {
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_SWITCH(_code_ptr[ip]) {
OPCODE(OPCODE_OPERATOR) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(5);
bool valid;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant::Operator op = (Variant::Operator)_code_ptr[ip + 1];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(op >= Variant::OP_MAX);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(a, 2);
GET_VARIANT_PTR(b, 3);
GET_VARIANT_PTR(dst, 4);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant ret;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant::evaluate(op, *a, *b, ret, valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant::evaluate(op, *a, *b, *dst, valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
#ifdef DEBUG_ENABLED
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
if (!valid) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (ret.get_type() == Variant::STRING) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//return a string when invalid with the error
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = ret;
err_text += " in operator '" + Variant::get_operator_name(op) + "'.";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Invalid operands '" + Variant::get_type_name(a->get_type()) + "' and '" + Variant::get_type_name(b->get_type()) + "' in operator '" + Variant::get_operator_name(op) + "'.";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = ret;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 5;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_EXTENDS_TEST) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(4);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(a, 1);
GET_VARIANT_PTR(b, 2);
GET_VARIANT_PTR(dst, 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
if (b->get_type() != Variant::OBJECT || b->operator Object *() == nullptr) {
GDScript: Use "is" keyword for type checking. Replaces the `extends` keyword with `is` in the context of testing for type compatibility. `extends` is still used for declaring class inheritance. Example: ```gdscript extends Node2D func _input(ev): if ev is InputEventKey: print("yay, key event") ```
2017-05-26 17:45:39 +00:00
err_text = "Right operand of 'is' is not a class.";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool extends_ok = false;
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
if (a->get_type() == Variant::OBJECT && a->operator Object *() != nullptr) {
GDScript: Validate object instance on `is` operation Avoids crashes on debug mode. Instead it now breaks the execution and show the error in-editor. Will still crash on release. Also add a similar check to Marshalls to ensure the debugger doesn't crash when trying to serialize the invalid instance.
2020-01-09 16:59:33 +00:00
#ifdef DEBUG_ENABLED
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
bool was_freed;
Object *obj_A = a->get_validated_object_with_check(was_freed);
if (was_freed) {
err_text = "Left operand of 'is' is a previously freed instance.";
GDScript: Validate object instance on `is` operation Avoids crashes on debug mode. Instead it now breaks the execution and show the error in-editor. Will still crash on release. Also add a similar check to Marshalls to ensure the debugger doesn't crash when trying to serialize the invalid instance.
2020-01-09 16:59:33 +00:00
OPCODE_BREAK;
}
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
Object *obj_B = b->get_validated_object_with_check(was_freed);
if (was_freed) {
err_text = "Right operand of 'is' is a previously freed instance.";
OPCODE_BREAK;
}
#else
Object *obj_A = *a;
Object *obj_B = *b;
GDScript: Validate object instance on `is` operation Avoids crashes on debug mode. Instead it now breaks the execution and show the error in-editor. Will still crash on release. Also add a similar check to Marshalls to ensure the debugger doesn't crash when trying to serialize the invalid instance.
2020-01-09 16:59:33 +00:00
#endif // DEBUG_ENABLED
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
GDScript *scr_B = Object::cast_to<GDScript>(obj_B);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
if (scr_B) {
//if B is a script, the only valid condition is that A has an instance which inherits from the script
//in other situation, this shoul return false.
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) {
GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr());
//bool found=false;
while (cmp) {
if (cmp == scr_B) {
//inherits from script, all ok
extends_ok = true;
break;
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
cmp = cmp->_base;
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
} else {
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(obj_B);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
if (!nc) {
err_text = "Right operand of 'is' is not a class (type: '" + obj_B->get_class() + "').";
OPCODE_BREAK;
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
extends_ok = ClassDB::is_parent_class(obj_A->get_class_name(), nc->get_name());
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = extends_ok;
ip += 4;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
GDScript: Allow `is` operator to test built-in types
2018-08-26 16:31:23 +00:00
OPCODE(OPCODE_IS_BUILTIN) {
CHECK_SPACE(4);
GET_VARIANT_PTR(value, 1);
Variant::Type var_type = (Variant::Type)_code_ptr[ip + 2];
GET_VARIANT_PTR(dst, 3);
GD_ERR_BREAK(var_type < 0 || var_type >= Variant::VARIANT_MAX);
*dst = value->get_type() == var_type;
ip += 4;
}
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_SET) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 1);
GET_VARIANT_PTR(index, 2);
GET_VARIANT_PTR(value, 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
bool valid;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
dst->set(*index, *value, &valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
String v = index->operator String();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (v != "") {
v = "'" + v + "'";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
v = "of type '" + _get_var_type(index) + "'";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Re-apply clang-format over recent invalid additions
2017-12-10 00:27:02 +00:00
err_text = "Invalid set index " + v + " (on base: '" + _get_var_type(dst) + "') with value of type '" + _get_var_type(value) + "'";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_GET) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(src, 1);
GET_VARIANT_PTR(index, 2);
GET_VARIANT_PTR(dst, 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
bool valid;
#ifdef DEBUG_ENABLED
//allow better error message in cases where src and dst are the same stack position
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant ret = src->get(*index, &valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = src->get(*index, &valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
String v = index->operator String();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (v != "") {
v = "'" + v + "'";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
v = "of type '" + _get_var_type(index) + "'";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Invalid get index " + v + " (on base: '" + _get_var_type(src) + "').";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = ret;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_SET_NAMED) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 1);
GET_VARIANT_PTR(value, 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int indexname = _code_ptr[ip + 2];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
const StringName *index = &_global_names_ptr[indexname];
bool valid;
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
dst->set_named(*index, *value, valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
String err_type;
Style: Re-apply clang-format over recent invalid additions
2017-12-10 00:27:02 +00:00
err_text = "Invalid set index '" + String(*index) + "' (on base: '" + _get_var_type(dst) + "') with value of type '" + _get_var_type(value) + "'.";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_GET_NAMED) {
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
CHECK_SPACE(4);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(src, 1);
GET_VARIANT_PTR(dst, 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int indexname = _code_ptr[ip + 2];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
const StringName *index = &_global_names_ptr[indexname];
bool valid;
#ifdef DEBUG_ENABLED
//allow better error message in cases where src and dst are the same stack position
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
Variant ret = src->get_named(*index, valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#else
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
*dst = src->get_named(*index, valid);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
if (src->has_method(*index)) {
Warn about funcref creation
2017-12-26 22:16:41 +00:00
err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "'). Did you mean '." + index->operator String() + "()' or funcref(obj, \"" + index->operator String() + "\") ?";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Invalid get index '" + index->operator String() + "' (on base: '" + _get_var_type(src) + "').";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = ret;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_SET_MEMBER) {
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int indexname = _code_ptr[ip + 1];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
const StringName *index = &_global_names_ptr[indexname];
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(src, 2);
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
bool valid;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#ifndef DEBUG_ENABLED
ClassDB::set_property(p_instance->owner, *index, *src, &valid);
#else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool ok = ClassDB::set_property(p_instance->owner, *index, *src, &valid);
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
if (!ok) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Internal error setting property: " + String(*index);
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
} else if (!valid) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Error setting property '" + String(*index) + "' with value of type " + Variant::get_type_name(src->get_type()) + ".";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_GET_MEMBER) {
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int indexname = _code_ptr[ip + 1];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(indexname < 0 || indexname >= _global_names_count);
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
const StringName *index = &_global_names_ptr[indexname];
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 2);
Revert cause of #22794
2018-10-06 10:30:45 +00:00
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#ifndef DEBUG_ENABLED
ClassDB::get_property(p_instance->owner, *index, *dst);
#else
bool ok = ClassDB::get_property(p_instance->owner, *index, *dst);
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
if (!ok) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Internal error getting property: " + String(*index);
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
-GDScript support for accessing properties directly -Added code lookup and code completion support for properties too
2017-01-04 20:37:45 +00:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ASSIGN) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 1);
GET_VARIANT_PTR(src, 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
*dst = *src;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ASSIGN_TRUE) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
*dst = true;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 2;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ASSIGN_FALSE) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
*dst = false;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 2;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
OPCODE(OPCODE_ASSIGN_TYPED_BUILTIN) {
CHECK_SPACE(4);
GET_VARIANT_PTR(dst, 2);
GET_VARIANT_PTR(src, 3);
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
Variant::Type var_type = (Variant::Type)_code_ptr[ip + 1];
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
GD_ERR_BREAK(var_type < 0 || var_type >= Variant::VARIANT_MAX);
if (src->get_type() != var_type) {
GDScript: Fix type conversion in assignment with operation
2019-12-13 14:35:01 +00:00
#ifdef DEBUG_ENABLED
GDScript: Allow strict conversion when assigning typed variables
2018-07-25 16:12:07 +00:00
if (Variant::can_convert_strict(src->get_type(), var_type)) {
GDScript: Fix type conversion in assignment with operation
2019-12-13 14:35:01 +00:00
#endif // DEBUG_ENABLED
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError ce;
GDScript: Allow strict conversion when assigning typed variables
2018-07-25 16:12:07 +00:00
*dst = Variant::construct(var_type, const_cast<const Variant **>(&src), 1, ce);
} else {
GDScript: Fix type conversion in assignment with operation
2019-12-13 14:35:01 +00:00
#ifdef DEBUG_ENABLED
GDScript: Allow strict conversion when assigning typed variables
2018-07-25 16:12:07 +00:00
err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
"' to a variable of type '" + Variant::get_type_name(var_type) + "'.";
OPCODE_BREAK;
}
} else {
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
#endif // DEBUG_ENABLED
GDScript: Allow strict conversion when assigning typed variables
2018-07-25 16:12:07 +00:00
*dst = *src;
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
}
ip += 4;
}
DISPATCH_OPCODE;
OPCODE(OPCODE_ASSIGN_TYPED_NATIVE) {
CHECK_SPACE(4);
GET_VARIANT_PTR(dst, 2);
GET_VARIANT_PTR(src, 3);
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
#ifdef DEBUG_ENABLED
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
GET_VARIANT_PTR(type, 1);
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *());
GD_ERR_BREAK(!nc);
Fix invalid comparison warnings: [-Wbool-compare] and [-Wenum-compare] Fixes the following GCC 5 warnings and actual bugs: ``` drivers/unix/net_socket_posix.cpp:562:28: warning: comparison between 'enum IP::Type' and 'enum NetSocket::Type' [-Wenum-compare] modules/gdscript/gdscript_function.cpp:792:26: warning: comparison of constant '17' with boolean expression is always true [-Wbool-compare] modules/gdscript/gdscript_function.cpp:792:26: warning: logical not is only applied to the left hand side of comparison [-Wlogical-not-parentheses] modules/gdscript/gdscript_parser.cpp:5082:58: warning: comparison of constant '6' with boolean expression is always false [-Wbool-compare] modules/gdscript/gdscript_parser.cpp:5082:58: warning: logical not is only applied to the left hand side of comparison [-Wlogical-not-parentheses] modules/mbedtls/stream_peer_mbed_tls.cpp:286:45: warning: comparison between 'enum StreamPeerTCP::Status' and 'enum StreamPeerSSL::Status' [-Wenum-compare] modules/mbedtls/stream_peer_mbed_tls.cpp:313:45: warning: comparison between 'enum StreamPeerTCP::Status' and 'enum StreamPeerSSL::Status' [-Wenum-compare] ```
2018-09-27 08:43:12 +00:00
if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
"' to a variable of type '" + nc->get_name() + "'.";
OPCODE_BREAK;
}
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
Object *src_obj = src->operator Object *();
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
err_text = "Trying to assign value of type '" + src_obj->get_class_name() +
"' to a variable of type '" + nc->get_name() + "'.";
OPCODE_BREAK;
}
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
#endif // DEBUG_ENABLED
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
*dst = *src;
ip += 4;
}
DISPATCH_OPCODE;
OPCODE(OPCODE_ASSIGN_TYPED_SCRIPT) {
CHECK_SPACE(4);
GET_VARIANT_PTR(dst, 2);
GET_VARIANT_PTR(src, 3);
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
#ifdef DEBUG_ENABLED
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
GET_VARIANT_PTR(type, 1);
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
Script *base_type = Object::cast_to<Script>(type->operator Object *());
GD_ERR_BREAK(!base_type);
if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
OPCODE_BREAK;
}
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
if (!scr_inst) {
err_text = "Trying to assign value of type '" + src->operator Object *()->get_class_name() +
"' to a variable of type '" + base_type->get_path().get_file() + "'.";
OPCODE_BREAK;
}
Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
bool valid = false;
while (src_type) {
if (src_type == base_type) {
valid = true;
break;
}
src_type = src_type->get_base_script().ptr();
}
if (!valid) {
err_text = "Trying to assign value of type '" + src->operator Object *()->get_script_instance()->get_script()->get_path().get_file() +
"' to a variable of type '" + base_type->get_path().get_file() + "'.";
OPCODE_BREAK;
}
}
GDScript: Fix type detection on Object typed assign Also make typed assigns a debug-only thing, so release builds are more lenient on errors.
2018-07-25 21:45:38 +00:00
#endif // DEBUG_ENABLED
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
*dst = *src;
ip += 4;
}
DISPATCH_OPCODE;
OPCODE(OPCODE_CAST_TO_BUILTIN) {
CHECK_SPACE(4);
Variant::Type to_type = (Variant::Type)_code_ptr[ip + 1];
GET_VARIANT_PTR(src, 2);
GET_VARIANT_PTR(dst, 3);
GD_ERR_BREAK(to_type < 0 || to_type >= Variant::VARIANT_MAX);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
*dst = Variant::construct(to_type, (const Variant **)&src, 1, err);
#ifdef DEBUG_ENABLED
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error != Callable::CallError::CALL_OK) {
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
err_text = "Invalid cast: could not convert value to '" + Variant::get_type_name(to_type) + "'.";
OPCODE_BREAK;
}
#endif
ip += 4;
}
DISPATCH_OPCODE;
OPCODE(OPCODE_CAST_TO_NATIVE) {
CHECK_SPACE(4);
GET_VARIANT_PTR(to_type, 1);
GET_VARIANT_PTR(src, 2);
GET_VARIANT_PTR(dst, 3);
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(to_type->operator Object *());
GD_ERR_BREAK(!nc);
#ifdef DEBUG_ENABLED
if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
err_text = "Invalid cast: can't convert a non-object value to an object type.";
OPCODE_BREAK;
}
#endif
Object *src_obj = src->operator Object *();
if (src_obj && !ClassDB::is_parent_class(src_obj->get_class_name(), nc->get_name())) {
*dst = Variant(); // invalid cast, assign NULL
} else {
*dst = *src;
}
ip += 4;
}
DISPATCH_OPCODE;
OPCODE(OPCODE_CAST_TO_SCRIPT) {
CHECK_SPACE(4);
GET_VARIANT_PTR(to_type, 1);
GET_VARIANT_PTR(src, 2);
GET_VARIANT_PTR(dst, 3);
Script *base_type = Object::cast_to<Script>(to_type->operator Object *());
GD_ERR_BREAK(!base_type);
#ifdef DEBUG_ENABLED
if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
err_text = "Trying to assign a non-object value to a variable of type '" + base_type->get_path().get_file() + "'.";
OPCODE_BREAK;
}
#endif
bool valid = false;
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
if (src->get_type() != Variant::NIL && src->operator Object *() != nullptr) {
Add typed instructions to GDScript - Typed assignment (built-in, native, and script). - Cast (built-in conversion; native and script checks). - Check type of functions arguments on call. - Check type of members on set.
2018-05-30 02:16:56 +00:00
ScriptInstance *scr_inst = src->operator Object *()->get_script_instance();
if (scr_inst) {
Script *src_type = src->operator Object *()->get_script_instance()->get_script().ptr();
while (src_type) {
if (src_type == base_type) {
valid = true;
break;
}
src_type = src_type->get_base_script().ptr();
}
}
}
if (valid) {
*dst = *src; // Valid cast, copy the source object
} else {
*dst = Variant(); // invalid cast, assign NULL
}
ip += 4;
}
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CONSTRUCT) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant::Type t = Variant::Type(_code_ptr[ip + 1]);
int argc = _code_ptr[ip + 2];
CHECK_SPACE(argc + 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant **argptrs = call_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(v, 3 + i);
argptrs[i] = v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 3 + argc);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = Variant::construct(t, (const Variant **)argptrs, argc, err);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error != Callable::CallError::CALL_OK) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = _get_call_error(err, "'" + Variant::get_type_name(t) + "' constructor", (const Variant **)argptrs);
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4 + argc;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//construct a basic type
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CONSTRUCT_ARRAY) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(1);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int argc = _code_ptr[ip + 1];
Both Array and Dictionary are always in shared mode (removed copy on write).
2017-01-11 11:53:31 +00:00
Array array; //arrays are always shared
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
array.resize(argc);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
CHECK_SPACE(argc + 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(v, 2 + i);
array[i] = *v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 2 + argc);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = array;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3 + argc;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CONSTRUCT_DICTIONARY) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(1);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int argc = _code_ptr[ip + 1];
Both Array and Dictionary are always in shared mode (removed copy on write).
2017-01-11 11:53:31 +00:00
Dictionary dict; //arrays are always shared
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
CHECK_SPACE(argc * 2 + 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(k, 2 + i * 2 + 0);
GET_VARIANT_PTR(v, 2 + i * 2 + 1);
dict[*k] = *v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, 2 + argc * 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = dict;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3 + argc * 2;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
OPCODE(OPCODE_CALL_ASYNC)
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CALL_RETURN)
OPCODE(OPCODE_CALL) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(4);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
bool call_ret = _code_ptr[ip] != OPCODE_CALL;
#ifdef DEBUG_ENABLED
bool call_async = _code_ptr[ip] == OPCODE_CALL_ASYNC;
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int argc = _code_ptr[ip + 1];
GET_VARIANT_PTR(base, 2);
int nameg = _code_ptr[ip + 3];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(nameg < 0 || nameg >= _global_names_count);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
const StringName *methodname = &_global_names_ptr[nameg];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(argc < 0);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4;
CHECK_SPACE(argc + 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant **argptrs = call_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(v, i);
argptrs[i] = v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#ifdef DEBUG_ENABLED
Fix use of unitialized variables The second in my quest to make Godot 3.x compile with -Werror on GCC7
2017-09-01 20:33:39 +00:00
uint64_t call_time = 0;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (GDScriptLanguage::get_singleton()->profiling) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
call_time = OS::get_singleton()->get_ticks_usec();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#endif
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (call_ret) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(ret, argc);
base->call_ptr(*methodname, (const Variant **)argptrs, argc, ret, err);
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
#ifdef DEBUG_ENABLED
if (!call_async && ret->get_type() == Variant::OBJECT) {
// Check if getting a function state without await.
bool was_freed = false;
Object *obj = ret->get_validated_object_with_check(was_freed);
if (was_freed) {
err_text = "Got a freed object as a result of the call.";
OPCODE_BREAK;
}
null pointer dereference at GDScriptFunction::call fix
2020-09-04 09:50:41 +00:00
if (obj && obj->is_class_ptr(GDScriptFunctionState::get_class_ptr_static())) {
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
err_text = R"(Trying to call an async function without "await".)";
OPCODE_BREAK;
}
}
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
base->call_ptr(*methodname, (const Variant **)argptrs, argc, nullptr, err);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#ifdef DEBUG_ENABLED
if (GDScriptLanguage::get_singleton()->profiling) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
function_call_time += OS::get_singleton()->get_ticks_usec() - call_time;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error != Callable::CallError::CALL_OK) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String methodstr = *methodname;
String basestr = _get_var_type(base);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (methodstr == "call") {
if (argc >= 1) {
methodstr = String(*argptrs[0]) + " (via call)";
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
Fix wrong error messages for invalid arguments when calling functions through call Fixes #25505
2019-01-31 15:02:18 +00:00
err.argument += 1;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (methodstr == "free") {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error == Callable::CallError::CALL_ERROR_INVALID_METHOD) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (base->is_ref()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Attempted to free a reference.";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (base->get_type() == Variant::OBJECT) {
err_text = "Attempted to free a locked object (calling or emitting).";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
Fixes the misleading error message for call_recursive method for TreeItems
2020-10-17 07:00:29 +00:00
} else if (methodstr == "call_recursive" && basestr == "TreeItem") {
if (argc >= 1) {
methodstr = String(*argptrs[0]) + " (via TreeItem.call_recursive)";
if (err.error == Callable::CallError::CALL_ERROR_INVALID_ARGUMENT) {
err.argument += 1;
}
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = _get_call_error(err, "function '" + methodstr + "' in base '" + basestr + "'", (const Variant **)argptrs);
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
//_call_func(nullptr,base,*methodname,ip,argc,p_instance,stack);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += argc + 1;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CALL_BUILT_IN) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(4);
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
GDScriptFunctions::Function func = GDScriptFunctions::Function(_code_ptr[ip + 1]);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int argc = _code_ptr[ip + 2];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(argc < 0);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 3;
CHECK_SPACE(argc + 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant **argptrs = call_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(v, i);
argptrs[i] = v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, argc);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
GDScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error != Callable::CallError::CALL_OK) {
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
String methodstr = GDScriptFunctions::get_func_name(func);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (dst->get_type() == Variant::STRING) {
Made many built-in gdscript functions return more descriptive errors, closes #5150
2016-06-11 22:43:38 +00:00
//call provided error string
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Error calling built-in function '" + methodstr + "': " + String(*dst);
Made many built-in gdscript functions return more descriptive errors, closes #5150
2016-06-11 22:43:38 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = _get_call_error(err, "built-in function '" + methodstr + "'", (const Variant **)argptrs);
Made many built-in gdscript functions return more descriptive errors, closes #5150
2016-06-11 22:43:38 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += argc + 1;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_CALL_SELF_BASE) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int self_fun = _code_ptr[ip + 1];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (self_fun < 0 || self_fun >= _global_names_count) {
err_text = "compiler bug, function name not found";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#endif
const StringName *methodname = &_global_names_ptr[self_fun];
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int argc = _code_ptr[ip + 2];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
CHECK_SPACE(2 + argc + 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant **argptrs = call_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < argc; i++) {
GET_VARIANT_PTR(v, i + 3);
argptrs[i] = v;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(dst, argc + 3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Revert "Fix crash on signal/resume to dangling target" This reverts commit 54bdc1e1f6a7fb85a5b193c9b8ecf0dcf06949e6.
2018-11-24 22:46:13 +00:00
const GDScript *gds = _script;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
const Map<StringName, GDScriptFunction *>::Element *E = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
while (gds->base.ptr()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
gds = gds->base.ptr();
E = gds->member_functions.find(*methodname);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (E) {
Fixed wrong break statement in GDFunction::call
2017-09-27 01:23:39 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (E) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else if (gds->native.ptr()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!mb) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
err.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
*dst = mb->call(p_instance->owner, (const Variant **)argptrs, argc, err);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
} else {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
err.error = Callable::CallError::CALL_OK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
} else {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
err.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
err.error = Callable::CallError::CALL_OK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
if (err.error != Callable::CallError::CALL_OK) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String methodstr = *methodname;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = _get_call_error(err, "function '" + methodstr + "'", (const Variant **)argptrs);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 4 + argc;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
OPCODE(OPCODE_AWAIT) {
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
CHECK_SPACE(2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
//do the oneshot connect
GET_VARIANT_PTR(argobj, 1);
Signal sig;
bool is_signal = true;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
{
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
Variant result = *argobj;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
if (argobj->get_type() == Variant::OBJECT) {
bool was_freed = false;
Object *obj = argobj->get_validated_object_with_check(was_freed);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
if (was_freed) {
err_text = "Trying to await on a freed object.";
OPCODE_BREAK;
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
// Is this even possible to be null at this point?
if (obj) {
if (obj->is_class_ptr(GDScriptFunctionState::get_class_ptr_static())) {
static StringName completed = _scs_create("completed");
result = Signal(obj, completed);
}
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix warnings on release builds (not DEBUG_ENABLED) Fixes the following Clang 5 warnings: ``` modules/bmp/image_loader_bmp.cpp:46:60: warning: comparison of unsigned expression < 0 is always false [-Wtautological-compare] modules/bmp/image_loader_bmp.cpp:48:61: warning: comparison of unsigned expression < 0 is always false [-Wtautological-compare] drivers/png/image_loader_png.cpp:231:20: warning: comparison of unsigned expression >= 0 is always true [-Wtautological-compare] scene/gui/graph_edit.cpp:1045:8: warning: comparison of constant 0 with expression of type 'bool' is always false [-Wtautological-constant-out-of-range-compare] core/class_db.cpp:812:13: warning: unused variable 'check' [-Wunused-variable] core/io/file_access_pack.cpp:172:11: warning: unused variable 'ver_rev' [-Wunused-variable] core/math/bsp_tree.cpp:195:13: warning: unused variable 'plane' [-Wunused-variable] core/math/bsp_tree.cpp:168:6: warning: unused variable 'plane_count' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:685:10: warning: unused variable 'ok' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:706:10: warning: unused variable 'ok' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:755:19: warning: unused variable 'var_type' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:1306:12: warning: unused variable 'err' [-Wunused-variable] modules/gdscript/gdscript_function.cpp:158:15: warning: unused function '_get_var_type' [-Wunused-function] modules/gdscript/gdscript_parser.cpp:750:20: warning: unused variable 'lv' [-Wunused-variable] modules/gdscript/gdscript_parser.cpp:59:15: warning: unused function '_find_function_name' [-Wunused-function] scene/main/node.cpp:2489:13: warning: unused function '_Node_debug_sn' [-Wunused-function] ```
2018-10-03 14:13:34 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
if (result.get_type() != Variant::SIGNAL) {
ip += 4; // Skip OPCODE_AWAIT_RESUME and its data.
// The stack pointer should be the same, so we don't need to set a return value.
is_signal = false;
} else {
sig = result;
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
}
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
if (is_signal) {
Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState);
gdfs->function = this;
gdfs->state.stack.resize(alloca_size);
//copy variant stack
for (int i = 0; i < _stack_size; i++) {
memnew_placement(&gdfs->state.stack.write[sizeof(Variant) * i], Variant(stack[i]));
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
gdfs->state.stack_size = _stack_size;
gdfs->state.self = self;
gdfs->state.alloca_size = alloca_size;
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
gdfs->state.ip = ip + 2;
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
gdfs->state.line = line;
gdfs->state.script = _script;
{
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
_script->pending_func_states.add(&gdfs->scripts_list);
if (p_instance) {
gdfs->state.instance = p_instance;
p_instance->pending_func_states.add(&gdfs->instances_list);
} else {
gdfs->state.instance = nullptr;
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
#ifdef DEBUG_ENABLED
gdfs->state.function_name = name;
gdfs->state.script_path = _script->get_path();
#endif
gdfs->state.defarg = defarg;
gdfs->function = this;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
retvalue = gdfs;
Error err = sig.connect(Callable(gdfs.ptr(), "_signal_callback"), varray(gdfs), Object::CONNECT_ONESHOT);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (err != OK) {
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
err_text = "Error connecting to signal: " + sig.get_name() + " during await.";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#ifdef DEBUG_ENABLED
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
exit_ok = true;
awaited = true;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#endif
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
OPCODE_BREAK;
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
DISPATCH_OPCODE; // Needed for synchronous calls (when result is immediately available).
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
OPCODE(OPCODE_AWAIT_RESUME) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!p_state) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = ("Invalid Resume (bug?)");
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(result, 1);
*result = p_state->result;
ip += 2;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_JUMP) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int to = _code_ptr[ip + 1];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(to < 0 || to > _code_size);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = to;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_JUMP_IF) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(test, 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool result = test->booleanize();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (result) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int to = _code_ptr[ip + 2];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(to < 0 || to > _code_size);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = to;
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
} else {
ip += 3;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_JUMP_IF_NOT) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(3);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(test, 1);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool result = test->booleanize();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!result) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int to = _code_ptr[ip + 2];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(to < 0 || to > _code_size);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = to;
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
} else {
ip += 3;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_JUMP_TO_DEF_ARGUMENT) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = _default_arg_ptr[defarg];
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_RETURN) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(r, 1);
retvalue = *r;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
exit_ok = true;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#endif
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ITERATE_BEGIN) {
Fix typos 'a' and 'an'
2017-09-02 14:19:06 +00:00
CHECK_SPACE(8); //space for this a regular iterate
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(counter, 1);
GET_VARIANT_PTR(container, 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
bool valid;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!container->iter_init(*counter, valid)) {
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
Fixed some obvious typos in error messages In some errors, there were closing quotation marks but no opening (e. g. "Unable to iterate on object of type " + Variant::get_type_name(container->get_type()) + "'."
2019-10-05 13:33:30 +00:00
err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "'.";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int jumpto = _code_ptr[ip + 3];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = jumpto;
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
} else {
GET_VARIANT_PTR(iterator, 4);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
*iterator = container->iter_get(*counter, valid);
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
if (!valid) {
Fixed some obvious typos in error messages In some errors, there were closing quotation marks but no opening (e. g. "Unable to iterate on object of type " + Variant::get_type_name(container->get_type()) + "'."
2019-10-05 13:33:30 +00:00
err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "'.";
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
OPCODE_BREAK;
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
ip += 5; //skip regular iterate which is always next
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ITERATE) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(4);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GET_VARIANT_PTR(counter, 1);
GET_VARIANT_PTR(container, 2);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
bool valid;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!container->iter_next(*counter, valid)) {
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!valid) {
Fixed some obvious typos in error messages In some errors, there were closing quotation marks but no opening (e. g. "Unable to iterate on object of type " + Variant::get_type_name(container->get_type()) + "'."
2019-10-05 13:33:30 +00:00
err_text = "Unable to iterate on object of type '" + Variant::get_type_name(container->get_type()) + "' (type changed since first iteration?).";
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int jumpto = _code_ptr[ip + 3];
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
GD_ERR_BREAK(jumpto < 0 || jumpto > _code_size);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip = jumpto;
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
} else {
GET_VARIANT_PTR(iterator, 4);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
*iterator = container->iter_get(*counter, valid);
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
if (!valid) {
Fixed some obvious typos in error messages In some errors, there were closing quotation marks but no opening (e. g. "Unable to iterate on object of type " + Variant::get_type_name(container->get_type()) + "'."
2019-10-05 13:33:30 +00:00
err_text = "Unable to obtain iterator object of type '" + Variant::get_type_name(container->get_type()) + "' (but was obtained on first iteration?).";
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
OPCODE_BREAK;
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
ip += 5; //loop again
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_ASSERT) {
GDScript: add an optional message parameter to assert() Before this patch, assert() only took the condition to assert on: assert(item_data) Now, it can optionally take a string that will be printed upon failure: assert(item_data, item_name + " has no item data in ItemDatabase") This makes it easier to immediately see what the issue is by being able to write informative failure messages. Thanks to @wiped1 for sharing their patch, upon which this is based. Closes #17082
2019-08-06 11:28:22 +00:00
CHECK_SPACE(3);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
GET_VARIANT_PTR(test, 1);
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool result = test->booleanize();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!result) {
GDScript: Fix assert message when no custom message is set
2020-05-26 23:38:44 +00:00
String message_str;
if (_code_ptr[ip + 2] != 0) {
GET_VARIANT_PTR(message, 2);
message_str = *message;
}
GDScript: add an optional message parameter to assert() Before this patch, assert() only took the condition to assert on: assert(item_data) Now, it can optionally take a string that will be printed upon failure: assert(item_data, item_name + " has no item data in ItemDatabase") This makes it easier to immediately see what the issue is by being able to write informative failure messages. Thanks to @wiped1 for sharing their patch, upon which this is based. Closes #17082
2019-08-06 11:28:22 +00:00
if (message_str.empty()) {
err_text = "Assertion failed.";
} else {
err_text = "Assertion failed: " + message_str;
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#endif
GDScript: add an optional message parameter to assert() Before this patch, assert() only took the condition to assert on: assert(item_data) Now, it can optionally take a string that will be printed upon failure: assert(item_data, item_name + " has no item data in ItemDatabase") This makes it easier to immediately see what the issue is by being able to write informative failure messages. Thanks to @wiped1 for sharing their patch, upon which this is based. Closes #17082
2019-08-06 11:28:22 +00:00
ip += 3;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_BREAKPOINT) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 02:30:20 +00:00
if (EngineDebugger::is_active()) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ip += 1;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_LINE) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
CHECK_SPACE(2);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
line = _code_ptr[ip + 1];
ip += 2;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 02:30:20 +00:00
if (EngineDebugger::is_active()) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
// line
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool do_break = false;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 02:30:20 +00:00
if (EngineDebugger::get_script_debugger()->get_lines_left() > 0) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (EngineDebugger::get_script_debugger()->get_depth() <= 0) {
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 02:30:20 +00:00
EngineDebugger::get_script_debugger()->set_lines_left(EngineDebugger::get_script_debugger()->get_lines_left() - 1);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
if (EngineDebugger::get_script_debugger()->get_lines_left() <= 0) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
do_break = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (EngineDebugger::get_script_debugger()->is_breakpoint(line, source)) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
do_break = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (do_break) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 02:30:20 +00:00
EngineDebugger::get_singleton()->line_poll();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Make sure we don't leak when an opcode is followed by itself When compiling with GCC it is now possible for an opcode followed by itself to never leave the scope it is currently in. This leads to a situation where the dtor of a scope local variable isn't called which in turn can lead to a memory leak. By moving the goto outside of the scope of each opcode we guarantee that all dtors have been called before the next opcode gets dispatched. this fixes #12401
2017-11-09 16:13:04 +00:00
DISPATCH_OPCODE;
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE(OPCODE_END) {
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
exit_ok = true;
Fix compiler warnings in GDScript module
2018-10-06 12:41:31 +00:00
#endif
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Cleanup some #if 0'd code
2017-12-17 14:29:39 +00:00
Remove unused #if 0'ed code
2020-01-21 20:32:27 +00:00
#if 0 // Enable for debugging.
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
default: {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_text = "Illegal opcode " + itos(_code_ptr[ip]) + " at address " + itos(ip);
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_BREAK;
Style: Cosmetic fixes to play nice with clang-format
2017-01-15 15:38:54 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODES_END
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#ifdef DEBUG_ENABLED
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (exit_ok) {
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_OUT;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//error
// function, file, line, error, explanation
String err_file;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->path != "") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_file = p_instance->script->path;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
} else if (script) {
Fix crash on signal/resume to dangling target Fixes #22443.
2018-10-17 18:36:47 +00:00
err_file = script->path;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
if (err_file == "") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_file = "<built-in>";
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String err_func = name;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (p_instance && ObjectDB::get_instance(p_instance->owner_id) != nullptr && p_instance->script->is_valid() && p_instance->script->name != "") {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
err_func = p_instance->script->name + "." + err_func;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int err_line = line;
if (err_text == "") {
err_text = "Internal Script Error! - opcode #" + itos(last_opcode) + " (report please).";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
// debugger break did not happen
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), ERR_HANDLER_SCRIPT);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Remove more GDScript runtime checks on release As a preparation for other performance enhancements to GDScript:call() start by removing more of the GDScript runtime checks on release. This code has been tested with 2d/platformer, 3d/platformer, 3d/materials_test, and goltorus. No regressions were found.
2017-09-18 22:06:27 +00:00
#endif
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODE_OUT;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Use computed goto to dispatch next opcode On compulers that define __GNUC__ use computed goto to directly dispatch the next instruction rather than going through another switch statement. This saves a jump and some comparisons. In tight loops this is is roughly 10% faster than the switch() method.
2017-09-23 18:06:58 +00:00
OPCODES_OUT
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
if (GDScriptLanguage::get_singleton()->profiling) {
uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
profile.total_time += time_taken;
profile.self_time += time_taken - function_call_time;
profile.frame_total_time += time_taken;
profile.frame_self_time += time_taken - function_call_time;
GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
// Check if this is the last time the function is resuming from await
// Will be true if never awaited as well
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
// When it's the last resume it will postpone the exit from stack,
// so the debugger knows which function triggered the resume of the next function (if any)
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
if (!p_state || awaited) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (EngineDebugger::is_active()) {
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
GDScriptLanguage::get_singleton()->exit_function();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix a crash when trying to run Godot debugger on a release build. The GDScriptLanguage::enter_function is wrapped in #ifdef DEBUG but the exit_function is not, resulting in a stack underflow error.
2018-05-01 22:40:30 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
if (_stack_size) {
//free stack
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
for (int i = 0; i < _stack_size; i++) {
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
stack[i].~Variant();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
}
#ifdef DEBUG_ENABLED
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return retvalue;
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
const int *GDScriptFunction::get_code() const {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return _code_ptr;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
int GDScriptFunction::get_code_size() const {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return _code_size;
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Variant GDScriptFunction::get_constant(int p_idx) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>");
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return constants[p_idx];
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
StringName GDScriptFunction::get_global_name(int p_idx) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX_V(p_idx, global_names.size(), "<errgname>");
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return global_names[p_idx];
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
int GDScriptFunction::get_default_argument_count() const {
GDScript: Fix returned value of get_default_argument_count()
2018-07-25 14:41:27 +00:00
return _default_arg_count;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
int GDScriptFunction::get_default_argument_addr(int p_idx) const {
Updated function argument names
2017-08-12 16:52:50 +00:00
ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), -1);
return default_arguments[p_idx];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Add static type checks in the parser - Resolve types for all identifiers. - Error when identifier is not found. - Match return type and error when not returning a value when it should. - Check unreachable code (code after sure return). - Match argument count and types for function calls. - Determine if return type of function call matches the assignment. - Do static type check with match statement when possible. - Use type hints to determine export type. - Check compatibility between type hint and explicit export type.
2018-05-30 02:16:54 +00:00
GDScriptDataType GDScriptFunction::get_return_type() const {
return return_type;
}
GDScriptDataType GDScriptFunction::get_argument_type(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, argument_types.size(), GDScriptDataType());
return argument_types[p_idx];
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
StringName GDScriptFunction::get_name() const {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return name;
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
int GDScriptFunction::get_max_stack_size() const {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return _stack_size;
}
struct _GDFKC {
int order;
List<int> pos;
};
struct _GDFKCS {
int order;
StringName id;
int pos;
bool operator<(const _GDFKCS &p_r) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return order < p_r.order;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
};
Style: Set clang-format Standard to Cpp11 For us, it practically only changes the fact that `A<A<int>>` is now used instead of the C++03 compatible `A<A<int> >`. Note: clang-format 10+ changed the `Standard` arguments to fully specified `c++11`, `c++14`, etc. versions, but we can't use `c++17` now if we want to preserve compatibility with clang-format 8 and 9. `Cpp11` is still supported as deprecated alias for `Latest`.
2020-03-17 06:33:00 +00:00
void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
int oc = 0;
Map<StringName, _GDFKC> sdmap;
for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) {
const StackDebug &sd = E->get();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (sd.line > p_line) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
break;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (sd.added) {
if (!sdmap.has(sd.identifier)) {
_GDFKC d;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
d.order = oc++;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
d.pos.push_back(sd.pos);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
sdmap[sd.identifier] = d;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
sdmap[sd.identifier].pos.push_back(sd.pos);
}
} else {
ERR_CONTINUE(!sdmap.has(sd.identifier));
sdmap[sd.identifier].pos.pop_back();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (sdmap[sd.identifier].pos.empty()) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
sdmap.erase(sd.identifier);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
List<_GDFKCS> stackpositions;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (Map<StringName, _GDFKC>::Element *E = sdmap.front(); E; E = E->next()) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
_GDFKCS spp;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
spp.id = E->key();
spp.order = E->get().order;
spp.pos = E->get().pos.back()->get();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
stackpositions.push_back(spp);
}
stackpositions.sort();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (List<_GDFKCS>::Element *E = stackpositions.front(); E; E = E->next()) {
Pair<StringName, int> p;
p.first = E->get().id;
p.second = E->get().pos;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
r_stackvars->push_back(p);
}
}
Style: Apply new clang-format 5.0 style to all files
2017-12-06 20:36:34 +00:00
GDScriptFunction::GDScriptFunction() :
function_list(this) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_stack_size = 0;
_call_size = 0;
Refactor RPCMode enum and checks
2018-05-13 05:07:56 +00:00
rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
name = "<anonymous>";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
_func_cname = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 10:28:13 +00:00
{
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 10:28:13 +00:00
GDScriptLanguage::get_singleton()->function_list.add(&function_list);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
profile.call_count = 0;
profile.self_time = 0;
profile.total_time = 0;
profile.frame_call_count = 0;
profile.frame_self_time = 0;
profile.frame_total_time = 0;
profile.last_frame_call_count = 0;
profile.last_frame_self_time = 0;
profile.last_frame_total_time = 0;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
GDScriptFunction::~GDScriptFunction() {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#ifdef DEBUG_ENABLED
Reimplement Mutex with C++'s <mutex> Main: - It's now implemented thanks to `<mutex>`. No more platform-specific implementations. - `BinaryMutex` (non-recursive) is added, as an alternative for special cases. - Doesn't need allocation/deallocation anymore. It can live in the stack and be part of other classes. - Because of that, it's methods are now `const` and the inner mutex is `mutable` so it can be easily used in `const` contexts. - A no-op implementation is provided if `NO_THREADS` is defined. No more need to add `#ifdef NO_THREADS` just for this. - `MutexLock` now takes a reference. At this point the cases of null `Mutex`es are rare. If you ever need that, just don't use `MutexLock`. - Thread-safe utilities are therefore simpler now. Misc.: - `ScopedMutexLock` is dropped and replaced by `MutexLock`, because they were pretty much the same. - Every case of lock, do-something, unlock is replaced by `MutexLock` (complex cases where it's not straightfoward are kept as as explicit lock and unlock). - `ShaderRD` contained an `std::mutex`, which has been replaced by `Mutex`.
2020-02-26 10:28:13 +00:00
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
GDScriptLanguage::get_singleton()->function_list.remove(&function_list);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
#endif
}
/////////////////////
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant arg;
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_error.error = Callable::CallError::CALL_OK;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
if (p_argcount == 0) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_error.argument = 1;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return Variant();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_argcount == 1) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//noooneee
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
} else if (p_argcount == 2) {
arg = *p_args[0];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
Array extra_args;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
for (int i = 0; i < p_argcount - 1; i++) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
extra_args.push_back(*p_args[i]);
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
arg = extra_args;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Ref<GDScriptFunctionState> self = *p_args[p_argcount - 1];
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (self.is_null()) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
r_error.argument = p_argcount - 1;
r_error.expected = Variant::OBJECT;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return Variant();
}
Fix stack underflows when yielding twice Also, refactor GDScriptFunctionState::_signal_callback, removing some excessive repetition. Fixes #30269.
2019-07-17 20:47:00 +00:00
return resume(arg);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (function == nullptr) {
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
if (p_extended_check) {
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
// Script gone?
if (!scripts_list.in_list()) {
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
return false;
Fix leaked objects when game ends with yields in progress
2020-04-29 11:38:00 +00:00
}
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
// Class instance gone? (if not static function)
if (state.instance && !instances_list.in_list()) {
Fix leaked objects when game ends with yields in progress
2020-04-29 11:38:00 +00:00
return false;
}
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
return true;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Variant GDScriptFunctionState::resume(const Variant &p_arg) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V(!function, Variant());
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
{
MutexLock lock(GDScriptLanguage::singleton->lock);
if (!scripts_list.in_list()) {
Fix crash on signal/resume to dangling target
2018-11-25 11:38:12 +00:00
#ifdef DEBUG_ENABLED
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after await, but script is gone. At script: " + state.script_path + ":" + itos(state.line));
Fix leaked objects when game ends with yields in progress
2020-04-29 11:38:00 +00:00
#else
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
return Variant();
Fix leaked objects when game ends with yields in progress
2020-04-29 11:38:00 +00:00
#endif
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
}
if (state.instance && !instances_list.in_list()) {
Fix leaked objects when game ends with yields in progress
2020-04-29 11:38:00 +00:00
#ifdef DEBUG_ENABLED
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after await, but class instance is gone. At script: " + state.script_path + ":" + itos(state.line));
Fix crash on signal/resume to dangling target
2018-11-25 11:38:12 +00:00
#else
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
return Variant();
Warn instad of crashing when class instance is gone after yield. Closes #5247 , probably closes other yield related crashes
2016-06-30 00:06:16 +00:00
#endif
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
}
// Do these now to avoid locking again after the call
scripts_list.remove_from_list();
instances_list.remove_from_list();
Fix crash on signal/resume to dangling target
2018-11-25 11:38:12 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
state.result = p_arg;
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Callable::CallError err;
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
Variant ret = function->call(nullptr, nullptr, 0, err, &state);
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
bool completed = true;
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
// If the return value is a GDScriptFunctionState reference,
New GDScript tokenizer and parser Sometimes to fix something you have to break it first. This get GDScript mostly working with the new tokenizer and parser but a lot of things isn't working yet. It compiles and it's usable, and that should be enough for now. Don't worry: other huge commits will come after this.
2020-05-01 22:14:56 +00:00
// then the function did awaited again after resuming.
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
if (ret.is_ref()) {
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
GDScriptFunctionState *gdfs = Object::cast_to<GDScriptFunctionState>(ret);
completed-signal is emitted by all GDScriptFunctionStates of a coroutine now, allowing to yield for completion of a function with more than one yield inside.
2018-03-14 15:42:13 +00:00
if (gdfs && gdfs->function == function) {
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
completed = false;
Fix memory leak in GDScript during infinnity loops with yields
2018-06-28 15:40:11 +00:00
gdfs->first_state = first_state.is_valid() ? first_state : Ref<GDScriptFunctionState>(this);
completed-signal is emitted by all GDScriptFunctionStates of a coroutine now, allowing to yield for completion of a function with more than one yield inside.
2018-03-14 15:42:13 +00:00
}
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
}
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
function = nullptr; //cleaned up;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
state.result = Variant();
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
if (completed) {
Fix memory leak in GDScript during infinnity loops with yields
2018-06-28 15:40:11 +00:00
if (first_state.is_valid()) {
first_state->emit_signal("completed", ret);
} else {
emit_signal("completed", ret);
completed-signal is emitted by all GDScriptFunctionStates of a coroutine now, allowing to yield for completion of a function with more than one yield inside.
2018-03-14 15:42:13 +00:00
}
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
#ifdef DEBUG_ENABLED
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (EngineDebugger::is_active()) {
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
GDScriptLanguage::get_singleton()->exit_function();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Keep GDScript functions in stack while yielding This prevents GDScript functions from leaving the stack too soon when they are resuming from yield, allowing the ones expecting it to finish to know the caller. Helps debugging cases when you use: `yield(function_which_yields(), "completed")` since now it shows the call that resumed that function.
2019-05-10 19:38:48 +00:00
#endif
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
}
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return ret;
}
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
void GDScriptFunctionState::_clear_stack() {
if (state.stack_size) {
Variant *stack = (Variant *)state.stack.ptr();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
for (int i = 0; i < state.stack_size; i++) {
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
stack[i].~Variant();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
state.stack_size = 0;
}
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
void GDScriptFunctionState::_bind_methods() {
ClassDB::bind_method(D_METHOD("resume", "arg"), &GDScriptFunctionState::resume, DEFVAL(Variant()));
ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDScriptFunctionState::is_valid, DEFVAL(false));
ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDScriptFunctionState::_signal_callback, MethodInfo("_signal_callback"));
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
Add NIL_IS_VARIANT usage to few definitions The missing usage flag led to GDNative API descriptions containting arguments with "void" type.
2017-10-05 11:44:00 +00:00
ADD_SIGNAL(MethodInfo("completed", PropertyInfo(Variant::NIL, "result", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
GDScriptFunctionState::GDScriptFunctionState() :
scripts_list(this),
instances_list(this) {
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
function = nullptr;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
GDScriptFunctionState::~GDScriptFunctionState() {
Fix object leaks caused by unfulfilled yields Now the stack saved in a `GDScriptFunctionState` is cleared as soon as the `yield()` operation is known not to be resumed because either the script, the instance or both are deleted. This clears problems like leaked objects by eliminating cases of circular references between `GDScriptFunctionState`s preventing them and the objects they refer to in their saved stacks from being released. As an example, this makes using `SceneTreeTimer` safer. Furthermore, with this change it's now possible to print early warnings about `yield()`s to released script/instances, as now we know they won't be successfully resumed as the condition for that happens. However, this PR doesn't add such messages, to keep the observed behavior the same for the time being. Also, now a backup of the function name in `GDScriptFunctionState` is used, since the script may not be valid by the time the function name is needed for the resume-after-yield error messages.
2020-05-05 10:53:05 +00:00
_clear_stack();
{
MutexLock lock(GDScriptLanguage::singleton->lock);
scripts_list.remove_from_list();
instances_list.remove_from_list();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
}
Add GDScript disassembler
2020-08-17 13:00:42 +00:00
#ifdef DEBUG_ENABLED
static String _get_variant_string(const Variant &p_variant) {
String txt;
if (p_variant.get_type() == Variant::STRING) {
txt = "\"" + String(p_variant) + "\"";
} else if (p_variant.get_type() == Variant::STRING_NAME) {
txt = "&\"" + String(p_variant) + "\"";
} else if (p_variant.get_type() == Variant::NODE_PATH) {
txt = "^\"" + String(p_variant) + "\"";
} else if (p_variant.get_type() == Variant::OBJECT) {
Object *obj = p_variant;
if (!obj) {
txt = "null";
} else {
GDScriptNativeClass *cls = Object::cast_to<GDScriptNativeClass>(obj);
if (cls) {
txt += cls->get_name();
txt += " (class)";
} else {
txt = obj->get_class();
if (obj->get_script_instance()) {
txt += "(" + obj->get_script_instance()->get_script()->get_path() + ")";
}
}
}
} else {
txt = p_variant;
}
return txt;
}
static String _disassemble_address(const GDScript *p_script, const GDScriptFunction &p_function, int p_address) {
int addr = p_address & GDScriptFunction::ADDR_MASK;
switch (p_address >> GDScriptFunction::ADDR_BITS) {
case GDScriptFunction::ADDR_TYPE_SELF: {
return "self";
} break;
case GDScriptFunction::ADDR_TYPE_CLASS: {
return "class";
} break;
case GDScriptFunction::ADDR_TYPE_MEMBER: {
return "member(" + p_script->debug_get_member_by_index(addr) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_CLASS_CONSTANT: {
return "class_const(" + p_function.get_global_name(addr) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT: {
return "const(" + _get_variant_string(p_function.get_constant(addr)) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_STACK: {
return "stack(" + itos(addr) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_STACK_VARIABLE: {
return "var_stack(" + itos(addr) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_GLOBAL: {
return "global(" + _get_variant_string(GDScriptLanguage::get_singleton()->get_global_array()[addr]) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_NAMED_GLOBAL: {
return "named_global(" + p_function.get_global_name(addr) + ")";
} break;
case GDScriptFunction::ADDR_TYPE_NIL: {
return "nil";
} break;
}
return "<err>";
}
void GDScriptFunction::disassemble(const Vector<String> &p_code_lines) const {
#define DADDR(m_ip) (_disassemble_address(_script, *this, _code_ptr[ip + m_ip]))
for (int ip = 0; ip < _code_size;) {
StringBuilder text;
int incr = 0;
text += " ";
text += itos(ip);
text += ": ";
// This makes the compiler complain if some opcode is unchecked in the switch.
Opcode code = Opcode(_code_ptr[ip]);
switch (code) {
case OPCODE_OPERATOR: {
int operation = _code_ptr[ip + 1];
text += "operator ";
text += DADDR(4);
text += " = ";
text += DADDR(2);
text += " ";
text += Variant::get_operator_name(Variant::Operator(operation));
text += " ";
text += DADDR(3);
incr += 5;
} break;
case OPCODE_EXTENDS_TEST: {
text += "is object ";
text += DADDR(3);
text += " = ";
text += DADDR(1);
text += " is ";
text += DADDR(2);
incr += 4;
} break;
case OPCODE_IS_BUILTIN: {
text += "is builtin ";
text += DADDR(3);
text += " = ";
text += DADDR(1);
text += " is ";
text += Variant::get_type_name(Variant::Type(_code_ptr[ip + 2]));
incr += 4;
} break;
case OPCODE_SET: {
text += "set ";
text += DADDR(1);
text += "[";
text += DADDR(2);
text += "] = ";
text += DADDR(3);
incr += 4;
} break;
case OPCODE_GET: {
text += "get ";
text += DADDR(3);
text += " = ";
text += DADDR(1);
text += "[";
text += DADDR(2);
text += "]";
incr += 4;
} break;
case OPCODE_SET_NAMED: {
text += "set_named ";
text += DADDR(1);
text += "[\"";
text += _global_names_ptr[_code_ptr[ip + 2]];
text += "\"] = ";
text += DADDR(3);
incr += 4;
} break;
case OPCODE_GET_NAMED: {
text += "get_named ";
text += DADDR(3);
text += " = ";
text += DADDR(1);
text += "[\"";
text += _global_names_ptr[_code_ptr[ip + 2]];
text += "\"]";
incr += 4;
} break;
case OPCODE_SET_MEMBER: {
text += "set_member ";
text += "[\"";
text += _global_names_ptr[_code_ptr[ip + 1]];
text += "\"] = ";
text += DADDR(2);
incr += 3;
} break;
case OPCODE_GET_MEMBER: {
text += "get_member ";
text += DADDR(2);
text += " = ";
text += "[\"";
text += _global_names_ptr[_code_ptr[ip + 1]];
text += "\"]";
incr += 3;
} break;
case OPCODE_ASSIGN: {
text += "assign ";
text += DADDR(1);
text += " = ";
text += DADDR(2);
incr += 3;
} break;
case OPCODE_ASSIGN_TRUE: {
text += "assign ";
text += DADDR(1);
text += " = true";
incr += 2;
} break;
case OPCODE_ASSIGN_FALSE: {
text += "assign ";
text += DADDR(1);
text += " = false";
incr += 2;
} break;
case OPCODE_ASSIGN_TYPED_BUILTIN: {
text += "assign typed builtin (";
text += Variant::get_type_name((Variant::Type)_code_ptr[ip + 1]);
text += ") ";
text += DADDR(2);
text += " = ";
text += DADDR(3);
incr += 4;
} break;
case OPCODE_ASSIGN_TYPED_NATIVE: {
Variant class_name = _constants_ptr[_code_ptr[ip + 1]];
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(class_name.operator Object *());
text += "assign typed native (";
text += nc->get_name().operator String();
text += ") ";
text += DADDR(2);
text += " = ";
text += DADDR(3);
incr += 4;
} break;
case OPCODE_ASSIGN_TYPED_SCRIPT: {
Variant script = _constants_ptr[_code_ptr[ip + 1]];
Script *sc = Object::cast_to<Script>(script.operator Object *());
text += "assign typed script (";
text += sc->get_path();
text += ") ";
text += DADDR(2);
text += " = ";
text += DADDR(3);
incr += 4;
} break;
case OPCODE_CAST_TO_BUILTIN: {
text += "cast builtin ";
text += DADDR(3);
text += " = ";
text += DADDR(2);
text += " as ";
text += Variant::get_type_name(Variant::Type(_code_ptr[ip + 1]));
incr += 4;
} break;
case OPCODE_CAST_TO_NATIVE: {
Variant class_name = _constants_ptr[_code_ptr[ip + 1]];
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(class_name.operator Object *());
text += "cast native ";
text += DADDR(3);
text += " = ";
text += DADDR(2);
text += " as ";
text += nc->get_name();
incr += 4;
} break;
case OPCODE_CAST_TO_SCRIPT: {
text += "cast ";
text += DADDR(3);
text += " = ";
text += DADDR(2);
text += " as ";
text += DADDR(1);
incr += 4;
} break;
case OPCODE_CONSTRUCT: {
Variant::Type t = Variant::Type(_code_ptr[ip + 1]);
int argc = _code_ptr[ip + 2];
text += "construct ";
text += DADDR(3 + argc);
text += " = ";
text += Variant::get_type_name(t) + "(";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(i + 3);
}
text += ")";
incr = 4 + argc;
} break;
case OPCODE_CONSTRUCT_ARRAY: {
int argc = _code_ptr[ip + 1];
text += " make_array ";
text += DADDR(2 + argc);
text += " = [";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(2 + i);
}
text += "]";
incr += 3 + argc;
} break;
case OPCODE_CONSTRUCT_DICTIONARY: {
int argc = _code_ptr[ip + 1];
text += "make_dict ";
text += DADDR(2 + argc * 2);
text += " = {";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(2 + i * 2 + 0);
text += ": ";
text += DADDR(2 + i * 2 + 1);
}
text += "}";
incr += 3 + argc * 2;
} break;
case OPCODE_CALL:
case OPCODE_CALL_RETURN:
case OPCODE_CALL_ASYNC: {
bool ret = _code_ptr[ip] == OPCODE_CALL_RETURN;
bool async = _code_ptr[ip] == OPCODE_CALL_ASYNC;
if (ret) {
text += "call-ret ";
} else if (async) {
text += "call-async ";
} else {
text += "call ";
}
int argc = _code_ptr[ip + 1];
if (ret || async) {
text += DADDR(4 + argc) + " = ";
}
text += DADDR(2) + ".";
text += String(_global_names_ptr[_code_ptr[ip + 3]]);
text += "(";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(4 + i);
}
text += ")";
incr = 5 + argc;
} break;
case OPCODE_CALL_BUILT_IN: {
text += "call-built-in ";
int argc = _code_ptr[ip + 2];
text += DADDR(3 + argc) + " = ";
text += GDScriptFunctions::get_func_name(GDScriptFunctions::Function(_code_ptr[ip + 1]));
text += "(";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(3 + i);
}
text += ")";
incr = 4 + argc;
} break;
case OPCODE_CALL_SELF_BASE: {
text += "call-self-base ";
int argc = _code_ptr[ip + 2];
text += DADDR(3 + argc) + " = ";
text += _global_names_ptr[_code_ptr[ip + 1]];
text += "(";
for (int i = 0; i < argc; i++) {
if (i > 0)
text += ", ";
text += DADDR(3 + i);
}
text += ")";
incr = 4 + argc;
} break;
case OPCODE_AWAIT: {
text += "await ";
text += DADDR(1);
incr += 2;
} break;
case OPCODE_AWAIT_RESUME: {
text += "await resume ";
text += DADDR(1);
incr = 2;
} break;
case OPCODE_JUMP: {
text += "jump ";
text += itos(_code_ptr[ip + 1]);
incr = 2;
} break;
case OPCODE_JUMP_IF: {
text += "jump-if ";
text += DADDR(1);
text += " to ";
text += itos(_code_ptr[ip + 2]);
incr = 3;
} break;
case OPCODE_JUMP_IF_NOT: {
text += "jump-if-not ";
text += DADDR(1);
text += " to ";
text += itos(_code_ptr[ip + 2]);
incr = 3;
} break;
case OPCODE_JUMP_TO_DEF_ARGUMENT: {
text += "jump-to-default-argument ";
incr = 1;
} break;
case OPCODE_RETURN: {
text += "return ";
text += DADDR(1);
incr = 2;
} break;
case OPCODE_ITERATE_BEGIN: {
text += "for-init ";
text += DADDR(4);
text += " in ";
text += DADDR(2);
text += " counter ";
text += DADDR(1);
text += " end ";
text += itos(_code_ptr[ip + 3]);
incr += 5;
} break;
case OPCODE_ITERATE: {
text += "for-loop ";
text += DADDR(4);
text += " in ";
text += DADDR(2);
text += " counter ";
text += DADDR(1);
text += " end ";
text += itos(_code_ptr[ip + 3]);
incr += 5;
} break;
case OPCODE_LINE: {
int line = _code_ptr[ip + 1] - 1;
if (line >= 0 && line < p_code_lines.size()) {
text += "line ";
text += itos(line + 1);
text += ": ";
text += p_code_lines[line];
} else {
text += "";
}
incr += 2;
} break;
case OPCODE_ASSERT: {
text += "assert (";
text += DADDR(1);
text += ", ";
text += DADDR(2);
text += ")";
incr += 3;
} break;
case OPCODE_BREAKPOINT: {
text += "breakpoint";
incr += 1;
} break;
case OPCODE_END: {
text += "== END ==";
incr += 1;
} break;
}
ip += incr;
if (text.get_string_length() > 0) {
print_line(text.as_string());
}
}
}
#endif