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

1975 lines
52 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
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). (cherry picked from commit 4d960efafc64f0f94f68158ca49ed7f3dd9742dc)
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 {
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 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.";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return NULL;
}
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). (cherry picked from commit 4d960efafc64f0f94f68158ca49ed7f3dd9742dc)
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.";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return NULL;
}
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
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(address, _global_names_count, NULL);
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) {
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
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 'ERR_EXPLAIN' with 'ERR_FAIL_*_MSG' in "platform", "modules/gdnative", "modules/gdscript" directories.
2019-08-09 04:49:33 +00:00
ERR_FAIL_V_MSG(NULL, "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
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(address, _constant_count, NULL);
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
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(address, _stack_size, NULL);
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
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(address, GDScriptLanguage::get_singleton()->get_global_array_size(), NULL);
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
ERR_FAIL_INDEX_V(address, _named_globals_count, NULL);
#endif
StringName id = _named_globals_ptr[address];
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.";
return NULL;
}
} 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 'ERR_EXPLAIN' with 'ERR_FAIL_*_MSG' in "platform", "modules/gdnative", "modules/gdscript" directories.
2019-08-09 04:49:33 +00:00
ERR_FAIL_V_MSG(NULL, "Bad code! (unknown addressing mode).");
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
return NULL;
}
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) {
Object *bobj = *p_var;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!bobj) {
basestr = "null instance";
} else {
if (ObjectDB::instance_validate(bobj)) {
if (bobj->get_script_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
basestr = bobj->get_class() + " (" + bobj->get_script_instance()->get_script()->get_path().get_file() + ")";
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
else
ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. All usages of "type" to refer to classes were renamed to "class" ClassDB has been exposed to GDScript. OBJ_TYPE() macro is now GDCLASS()
2017-01-03 02:03:46 +00:00
basestr = bobj->get_class();
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
basestr = "previously freed instance";
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
String GDScriptFunction::_get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const {
String err_text;
if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
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
{
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(p_err.expected) + ".";
}
} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS) {
err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
} else if (p_err.error == Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS) {
err_text = "Invalid call to " + p_where + ". Expected " + itos(p_err.argument) + " arguments.";
} else if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_METHOD) {
err_text = "Invalid call. Nonexistent " + p_where + ".";
} else if (p_err.error == Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL) {
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, \
&&OPCODE_CALL_BUILT_IN, \
&&OPCODE_CALL_SELF, \
&&OPCODE_CALL_SELF_BASE, \
&&OPCODE_YIELD, \
&&OPCODE_YIELD_SIGNAL, \
&&OPCODE_YIELD_RESUME, \
&&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 \
};
#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
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state) {
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_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();
}
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.error = Variant::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). (cherry picked from commit 4d960efafc64f0f94f68158ca49ed7f3dd9742dc)
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;
Variant *stack = NULL;
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) {
//use existing (supplied) state (yielded)
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 leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
script = p_state->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
p_instance = p_state->instance;
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
//stack[p_state->result_pos]=p_state->result; //assign stack with result
} 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) {
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 > _argument_count) {
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
r_err.error = Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
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) {
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.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
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)) {
if (argument_types[i].is_type(Variant(), true)) {
Allow parameters passed to GDScript functions to be nulled Previous version resulted in confusing (but actually right) errors about converting "from Object to Object", since CallError does not include information about the actual types involved.
2019-03-03 13:24:06 +00:00
memnew_placement(&stack[i], Variant);
continue;
} else {
r_err.error = Variant::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 {
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 = NULL;
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 {
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 = NULL;
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
stack = NULL;
call_args = NULL;
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()) {
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
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 (cherry picked from commit 0f1da724924fc494bfd316c57757e0e1d7b90143)
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
if (ScriptDebugger::get_singleton())
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);
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). (cherry picked from commit 4d960efafc64f0f94f68158ca49ed7f3dd9742dc)
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). (cherry picked from commit 4d960efafc64f0f94f68158ca49ed7f3dd9742dc)
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;
Fix yield check in GDScriptFunction Fixes #31455
2019-08-28 08:15:43 +00:00
bool yielded = 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]) {
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(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) {
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 (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
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 (b->get_type() != Variant::OBJECT || b->operator Object *() == NULL) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
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;
Allow primitives to be compared to Object types with `is`
2018-11-18 00:41:08 +00:00
if (a->get_type() == Variant::OBJECT && a->operator Object *() != NULL) {
Object *obj_A = *a;
Object *obj_B = *b;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
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
if (!ObjectDB::instance_validate(obj_A)) {
err_text = "Left operand of 'is' was already freed.";
OPCODE_BREAK;
}
#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()) {
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
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 {
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
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) {
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
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;
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_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) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
-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
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_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
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_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
GDScript: Allow strict conversion when assigning typed variables
2018-07-25 16:12:07 +00:00
Variant::CallError ce;
*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;
}
if (src->get_type() != Variant::NIL && src->operator Object *() != NULL) {
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);
Variant::CallError err;
*dst = Variant::construct(to_type, (const Variant **)&src, 1, err);
#ifdef DEBUG_ENABLED
if (err.error != Variant::CallError::CALL_OK) {
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;
if (src->get_type() != Variant::NIL && src->operator Object *() != NULL) {
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);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant::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
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.error != Variant::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
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++) {
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(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;
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);
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 call_ret = _code_ptr[ip] == OPCODE_CALL_RETURN;
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
Variant::CallError err;
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);
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
base->call_ptr(*methodname, (const Variant **)argptrs, argc, NULL, 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
}
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.error != Variant::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)";
if (err.error == Variant::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") {
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 (err.error == Variant::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) {
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 = "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 (cherry picked from commit c37f6332164380e626ba2f2d6caf056b2e8222bd)
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 == Variant::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
//_call_func(NULL,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
Variant::CallError err;
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
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.error != Variant::CallError::CALL_OK) {
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
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) {
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;
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_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) {
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 = "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
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
const Map<StringName, GDScriptFunction *>::Element *E = NULL;
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);
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (E)
Fixed wrong break statement in GDFunction::call
2017-09-27 01:23:39 +00:00
break;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}
Variant::CallError err;
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) {
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
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) {
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.error = Variant::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 {
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.error = Variant::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) {
err.error = Variant::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
err.error = Variant::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 (err.error != Variant::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;
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_YIELD)
OPCODE(OPCODE_YIELD_SIGNAL) {
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 ipofs = 1;
if (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
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
ipofs += 2;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
} else {
CHECK_SPACE(2);
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState);
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
gdfs->function = this;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
gdfs->state.stack.resize(alloca_size);
//copy variant 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
for (int i = 0; i < _stack_size; i++) {
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
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
}
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
gdfs->state.stack_size = _stack_size;
gdfs->state.self = self;
gdfs->state.alloca_size = alloca_size;
gdfs->state.ip = ip + ipofs;
gdfs->state.line = line;
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
gdfs->state.script = _script;
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 15:49:17 +00:00
#ifndef NO_THREADS
GDScriptLanguage::singleton->lock->lock();
#endif
_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 = NULL;
}
#ifndef NO_THREADS
GDScriptLanguage::singleton->lock->unlock();
#endif
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
#ifdef DEBUG_ENABLED
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 15:49:17 +00:00
gdfs->state.function_name = name;
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
gdfs->state.script_path = _script->get_path();
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
//gdfs->state.result_pos=ip+ipofs-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
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
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
retvalue = gdfs;
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 (_code_ptr[ip] == OPCODE_YIELD_SIGNAL) {
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
//do the oneshot connect
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(argobj, 1);
GET_VARIANT_PTR(argname, 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
#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 (argobj->get_type() != Variant::OBJECT) {
err_text = "First argument of yield() not of type object.";
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
if (argname->get_type() != Variant::STRING) {
err_text = "Second argument of yield() not a string (for signal name).";
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
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
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
Object *obj = argobj->operator Object *();
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
String signal = argname->operator String();
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
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
if (!obj) {
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 = "First argument of yield() is null.";
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
}
if (ScriptDebugger::get_singleton()) {
if (!ObjectDB::instance_validate(obj)) {
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 = "First argument of yield() is a previously freed instance.";
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
if (signal.length() == 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
err_text = "Second argument of yield() is an empty string (for signal name).";
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
Error err = obj->connect(signal, gdfs.ptr(), "_signal_callback", varray(gdfs), Object::CONNECT_ONESHOT);
if (err != OK) {
err_text = "Error connecting to signal: " + signal + " during yield().";
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 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
#else
obj->connect(signal, gdfs.ptr(), "_signal_callback", varray(gdfs), Object::CONNECT_ONESHOT);
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
}
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 yield check in GDScriptFunction Fixes #31455
2019-08-28 08:15:43 +00:00
yielded = 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_YIELD_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) {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
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 (cherry picked from commit f29a2e2606317e0964ffed287187afe6bf115626)
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
if (ScriptDebugger::get_singleton()) {
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
if (ScriptDebugger::get_singleton()) {
// 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
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 (ScriptDebugger::get_singleton()->get_lines_left() > 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
if (ScriptDebugger::get_singleton()->get_depth() <= 0)
ScriptDebugger::get_singleton()->set_lines_left(ScriptDebugger::get_singleton()->get_lines_left() - 1);
if (ScriptDebugger::get_singleton()->get_lines_left() <= 0)
do_break = true;
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 (ScriptDebugger::get_singleton()->is_breakpoint(line, source))
do_break = true;
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
}
ScriptDebugger::get_singleton()->line_poll();
}
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
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +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;
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;
GDScript: validate instance before accessing it on error Make sure the instance is valid before trying to access the script in after an error happened. If the instance is not valid it's possible that the script is invalid as well. Fix #29623
2019-11-01 17:37:32 +00:00
if (p_instance && ObjectDB::instance_validate(p_instance->owner) && 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;
Fix crash on signal/resume to dangling target Fixes #22443.
2018-10-17 18:36:47 +00:00
else if (script)
err_file = 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
if (err_file == "")
err_file = "<built-in>";
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;
GDScript: validate instance before accessing it on error Make sure the instance is valid before trying to access the script in after an error happened. If the instance is not valid it's possible that the script is invalid as well. Fix #29623
2019-11-01 17:37:32 +00:00
if (p_instance && ObjectDB::instance_validate(p_instance->owner) && 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;
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
}
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
// Check if this is the last time the function is resuming from yield
// Will be true if never yielded as well
// 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)
if (!p_state || yielded) {
if (ScriptDebugger::get_singleton())
GDScriptLanguage::get_singleton()->exit_function();
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
for (int i = 0; i < _stack_size; i++)
stack[i].~Variant();
}
#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;
}
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 {
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_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 {
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_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 {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
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
}
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 {
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
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
}
};
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int> > *r_stackvars) const {
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 oc = 0;
Map<StringName, _GDFKC> sdmap;
for (const List<StackDebug>::Element *E = stack_debug.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
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
const StackDebug &sd = E->get();
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;
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();
if (sdmap[sd.identifier].pos.empty())
sdmap.erase(sd.identifier);
}
}
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()) {
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
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) {
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
_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
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
_func_cname = NULL;
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()->lock) {
GDScriptLanguage::get_singleton()->lock->lock();
}
GDScriptLanguage::get_singleton()->function_list.add(&function_list);
if (GDScriptLanguage::get_singleton()->lock) {
GDScriptLanguage::get_singleton()->lock->unlock();
}
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
if (GDScriptLanguage::get_singleton()->lock) {
GDScriptLanguage::get_singleton()->lock->lock();
}
GDScriptLanguage::get_singleton()->function_list.remove(&function_list);
if (GDScriptLanguage::get_singleton()->lock) {
GDScriptLanguage::get_singleton()->lock->unlock();
}
#endif
}
/////////////////////
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::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;
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.error = Variant::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) {
r_error.error = Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
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()) {
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.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
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 {
Add extended check option to GDFunctionState::is_valid()
2017-05-17 12:47:17 +00:00
if (function == NULL)
return false;
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 15:49:17 +00:00
#ifndef NO_THREADS
MutexLock lock(GDScriptLanguage::get_singleton()->lock);
#endif
// Script gone?
if (!scripts_list.in_list()) {
return false;
}
// Class instance gone? (if not static function)
if (state.instance && !instances_list.in_list()) {
return false;
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
}
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) {
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_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 15:49:17 +00:00
{
#ifndef NO_THREADS
MutexLock lock(GDScriptLanguage::singleton->lock);
#endif
if (!scripts_list.in_list()) {
Fix crash on signal/resume to dangling target
2018-11-25 11:38:12 +00:00
#ifdef DEBUG_ENABLED
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 15:49:17 +00:00
ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after yield, but script 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 leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +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 leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +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 15:49:17 +00:00
if (state.instance && !instances_list.in_list()) {
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
#ifdef DEBUG_ENABLED
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 15:49:17 +00:00
ERR_FAIL_V_MSG(Variant(), "Resumed function '" + state.function_name + "()' after yield, but class instance is gone. At script: " + state.script_path + ":" + itos(state.line));
Fix leaked objects when game ends with yields in progress
2020-04-29 11:45:44 +00:00
#else
return Variant();
#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 15:49:17 +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;
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
Variant::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
Variant ret = function->call(NULL, NULL, 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,
Adds completed signal to GDFunctionState
2017-06-23 00:29:23 +00:00
// then the function did yield again after resuming.
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
}
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 = NULL; //cleaned up;
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
if (ScriptDebugger::get_singleton())
GDScriptLanguage::get_singleton()->exit_function();
#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 15:49:17 +00:00
void GDScriptFunctionState::_clear_stack() {
if (state.stack_size) {
Variant *stack = (Variant *)state.stack.ptr();
for (int i = 0; i < state.stack_size; i++)
stack[i].~Variant();
state.stack_size = 0;
}
}
GDScript: Refactor "GD" class prefix to "GDScript"
2017-11-16 17:38:18 +00:00
void GDScriptFunctionState::_bind_methods() {
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
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 15:49:17 +00:00
GDScriptFunctionState::GDScriptFunctionState() :
scripts_list(this),
instances_list(this) {
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
function = NULL;
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() {
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 15:49:17 +00:00
_clear_stack();
#ifndef NO_THREADS
GDScriptLanguage::singleton->lock->lock();
#endif
scripts_list.remove_from_list();
instances_list.remove_from_list();
#ifndef NO_THREADS
GDScriptLanguage::singleton->lock->unlock();
#endif
Some cleanup to GDScript separated GDFunction (VM) from GDScript in two different files
2016-06-01 01:28:27 +00:00
}