Relintai/pandemonium_engine
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine.git synced 2025-02-21 23:18:00 +01:00
Code Issues Packages Projects Releases Wiki Activity

Mass rename classes in the cscript module.

Browse Source
This commit is contained in:
Relintai 2022-07-12 19:55:21 +02:00
parent e687fc6a4a
commit e92d4e0f97
19 changed files with 2563 additions and 2565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

562
modules/cscript/cscript.cpp
View File

File diff suppressed because it is too large Load Diff

122
modules/cscript/cscript.h
View File

@ -35,8 +35,8 @@
#include "core/script_language.h" #include "core/script_language.h"
#include "cscript_function.h" #include "cscript_function.h"
class GDScriptNativeClass : public Reference { class CScriptNativeClass : public Reference {
GDCLASS(GDScriptNativeClass, Reference); GDCLASS(CScriptNativeClass, Reference);
StringName name; StringName name;
@ -48,11 +48,11 @@ public:
_FORCE_INLINE_ const StringName &get_name() const { return name; } _FORCE_INLINE_ const StringName &get_name() const { return name; }
Variant _new(); Variant _new();
Object *instance(); Object *instance();
GDScriptNativeClass(const StringName &p_name); CScriptNativeClass(const StringName &p_name);
}; };
class GDScript : public Script { class CScript : public Script {
GDCLASS(GDScript, Script); GDCLASS(CScript, Script);
bool tool; bool tool;
bool valid; bool valid;
@ -61,25 +61,25 @@ class GDScript : public Script {
StringName setter; StringName setter;
StringName getter; StringName getter;
MultiplayerAPI::RPCMode rpc_mode; MultiplayerAPI::RPCMode rpc_mode;
GDScriptDataType data_type; CScriptDataType data_type;
}; };
friend class GDScriptInstance; friend class CScriptInstance;
friend class GDScriptFunction; friend class CScriptFunction;
friend class GDScriptCompiler; friend class CScriptCompiler;
friend class GDScriptFunctions; friend class CScriptFunctions;
friend class GDScriptLanguage; friend class CScriptLanguage;
Ref<GDScriptNativeClass> native; Ref<CScriptNativeClass> native;
Ref<GDScript> base; Ref<CScript> base;
GDScript *_base; //fast pointer access CScript *_base; //fast pointer access
GDScript *_owner; //for subclasses CScript *_owner; //for subclasses
Set<StringName> members; //members are just indices to the instanced script. Set<StringName> members; //members are just indices to the instanced script.
Map<StringName, Variant> constants; Map<StringName, Variant> constants;
Map<StringName, GDScriptFunction *> member_functions; Map<StringName, CScriptFunction *> member_functions;
Map<StringName, MemberInfo> member_indices; //members are just indices to the instanced script. Map<StringName, MemberInfo> member_indices; //members are just indices to the instanced script.
Map<StringName, Ref<GDScript>> subclasses; Map<StringName, Ref<CScript>> subclasses;
Map<StringName, Vector<StringName>> _signals; Map<StringName, Vector<StringName>> _signals;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
@ -90,7 +90,7 @@ class GDScript : public Script {
List<PropertyInfo> members_cache; List<PropertyInfo> members_cache;
Map<StringName, Variant> member_default_values_cache; Map<StringName, Variant> member_default_values_cache;
Ref<GDScript> base_cache; Ref<CScript> base_cache;
Set<ObjectID> inheriters_cache; Set<ObjectID> inheriters_cache;
bool source_changed_cache; bool source_changed_cache;
bool placeholder_fallback_enabled; bool placeholder_fallback_enabled;
@ -99,7 +99,7 @@ class GDScript : public Script {
#endif #endif
Map<StringName, PropertyInfo> member_info; Map<StringName, PropertyInfo> member_info;
GDScriptFunction *initializer; //direct pointer to _init , faster to locate CScriptFunction *initializer; //direct pointer to _init , faster to locate
int subclass_count; int subclass_count;
Set<Object *> instances; Set<Object *> instances;
@ -108,14 +108,14 @@ class GDScript : public Script {
String path; String path;
String name; String name;
String fully_qualified_name; String fully_qualified_name;
SelfList<GDScript> script_list; SelfList<CScript> script_list;
SelfList<GDScriptFunctionState>::List pending_func_states; SelfList<CScriptFunctionState>::List pending_func_states;
void _clear_pending_func_states(); void _clear_pending_func_states();
GDScriptInstance *_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error); CScriptInstance *_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error);
void _set_subclass_path(Ref<GDScript> &p_sc, const String &p_path); void _set_subclass_path(Ref<CScript> &p_sc, const String &p_path);
String _get_debug_path() const; String _get_debug_path() const;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
@ -151,7 +151,7 @@ public:
bool inherits_script(const Ref<Script> &p_script) const; bool inherits_script(const Ref<Script> &p_script) const;
const Map<StringName, Ref<GDScript>> &get_subclasses() const { const Map<StringName, Ref<CScript>> &get_subclasses() const {
return subclasses; return subclasses;
} }
const Map<StringName, Variant> &get_constants() const { const Map<StringName, Variant> &get_constants() const {
@ -160,14 +160,14 @@ public:
const Set<StringName> &get_members() const { const Set<StringName> &get_members() const {
return members; return members;
} }
const GDScriptDataType &get_member_type(const StringName &p_member) const { const CScriptDataType &get_member_type(const StringName &p_member) const {
CRASH_COND(!member_indices.has(p_member)); CRASH_COND(!member_indices.has(p_member));
return member_indices[p_member].data_type; return member_indices[p_member].data_type;
} }
const Map<StringName, GDScriptFunction *> &get_member_functions() const { const Map<StringName, CScriptFunction *> &get_member_functions() const {
return member_functions; return member_functions;
} }
const Ref<GDScriptNativeClass> &get_native() const { const Ref<CScriptNativeClass> &get_native() const {
return native; return native;
} }
const String &get_script_class_name() const { const String &get_script_class_name() const {
@ -180,12 +180,12 @@ public:
bool is_tool() const { bool is_tool() const {
return tool; return tool;
} }
Ref<GDScript> get_base() const; Ref<CScript> get_base() const;
const Map<StringName, MemberInfo> &debug_get_member_indices() const { const Map<StringName, MemberInfo> &debug_get_member_indices() const {
return member_indices; return member_indices;
} }
const Map<StringName, GDScriptFunction *> &debug_get_member_functions() const; //this is debug only const Map<StringName, CScriptFunction *> &debug_get_member_functions() const; //this is debug only
StringName debug_get_member_by_index(int p_idx) const; StringName debug_get_member_by_index(int p_idx) const;
Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error); Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
@ -241,27 +241,27 @@ public:
} }
#endif #endif
GDScript(); CScript();
~GDScript(); ~CScript();
}; };
class GDScriptInstance : public ScriptInstance { class CScriptInstance : public ScriptInstance {
friend class GDScript; friend class CScript;
friend class GDScriptFunction; friend class CScriptFunction;
friend class GDScriptFunctions; friend class CScriptFunctions;
friend class GDScriptCompiler; friend class CScriptCompiler;
Object *owner; Object *owner;
Ref<GDScript> script; Ref<CScript> script;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
Map<StringName, int> member_indices_cache; //used only for hot script reloading Map<StringName, int> member_indices_cache; //used only for hot script reloading
#endif #endif
Vector<Variant> members; Vector<Variant> members;
bool base_ref; bool base_ref;
SelfList<GDScriptFunctionState>::List pending_func_states; SelfList<CScriptFunctionState>::List pending_func_states;
void _ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount); void _ml_call_reversed(CScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount);
public: public:
virtual Object *get_owner() { virtual Object *get_owner() {
@ -295,12 +295,12 @@ public:
virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const; virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const;
virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const; virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const;
GDScriptInstance(); CScriptInstance();
~GDScriptInstance(); ~CScriptInstance();
}; };
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
struct GDScriptWarning { struct CScriptWarning {
enum Code { enum Code {
UNASSIGNED_VARIABLE, // Variable used but never assigned UNASSIGNED_VARIABLE, // Variable used but never assigned
UNASSIGNED_VARIABLE_OP_ASSIGN, // Variable never assigned but used in an assignment operation (+=, *=, etc) UNASSIGNED_VARIABLE_OP_ASSIGN, // Variable never assigned but used in an assignment operation (+=, *=, etc)
@ -340,16 +340,16 @@ struct GDScriptWarning {
static String get_name_from_code(Code p_code); static String get_name_from_code(Code p_code);
static Code get_code_from_name(const String &p_name); static Code get_code_from_name(const String &p_name);
GDScriptWarning() : CScriptWarning() :
code(WARNING_MAX), code(WARNING_MAX),
line(-1) {} line(-1) {}
}; };
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
class GDScriptLanguage : public ScriptLanguage { class CScriptLanguage : public ScriptLanguage {
friend class GDScriptFunctionState; friend class CScriptFunctionState;
static GDScriptLanguage *singleton; static CScriptLanguage *singleton;
Variant *_global_array; Variant *_global_array;
Vector<Variant> global_array; Vector<Variant> global_array;
@ -358,8 +358,8 @@ class GDScriptLanguage : public ScriptLanguage {
struct CallLevel { struct CallLevel {
Variant *stack; Variant *stack;
GDScriptFunction *function; CScriptFunction *function;
GDScriptInstance *instance; CScriptInstance *instance;
int *ip; int *ip;
int *line; int *line;
}; };
@ -373,16 +373,16 @@ class GDScriptLanguage : public ScriptLanguage {
void _add_global(const StringName &p_name, const Variant &p_value); void _add_global(const StringName &p_name, const Variant &p_value);
friend class GDScriptInstance; friend class CScriptInstance;
Mutex lock; Mutex lock;
friend class GDScript; friend class CScript;
SelfList<GDScript>::List script_list; SelfList<CScript>::List script_list;
friend class GDScriptFunction; friend class CScriptFunction;
SelfList<GDScriptFunction>::List function_list; SelfList<CScriptFunction>::List function_list;
bool profiling; bool profiling;
uint64_t script_frame_time; uint64_t script_frame_time;
@ -394,7 +394,7 @@ public:
bool debug_break(const String &p_error, bool p_allow_continue = true); bool debug_break(const String &p_error, bool p_allow_continue = true);
bool debug_break_parse(const String &p_file, int p_line, const String &p_error); bool debug_break_parse(const String &p_file, int p_line, const String &p_error);
_FORCE_INLINE_ void enter_function(GDScriptInstance *p_instance, GDScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) { _FORCE_INLINE_ void enter_function(CScriptInstance *p_instance, CScriptFunction *p_function, Variant *p_stack, int *p_ip, int *p_line) {
if (Thread::get_main_id() != Thread::get_caller_id()) { if (Thread::get_main_id() != Thread::get_caller_id()) {
return; //no support for other threads than main for now return; //no support for other threads than main for now
} }
@ -468,7 +468,7 @@ public:
_FORCE_INLINE_ const Map<StringName, int> &get_global_map() const { return globals; } _FORCE_INLINE_ const Map<StringName, int> &get_global_map() const { return globals; }
_FORCE_INLINE_ const Map<StringName, Variant> &get_named_globals_map() const { return named_globals; } _FORCE_INLINE_ const Map<StringName, Variant> &get_named_globals_map() const { return named_globals; }
_FORCE_INLINE_ static GDScriptLanguage *get_singleton() { return singleton; } _FORCE_INLINE_ static CScriptLanguage *get_singleton() { return singleton; }
virtual String get_name() const; virtual String get_name() const;
@ -542,13 +542,13 @@ public:
virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const; virtual String get_global_class_name(const String &p_path, String *r_base_type = nullptr, String *r_icon_path = nullptr) const;
void add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass); void add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass);
Ref<GDScript> get_orphan_subclass(const String &p_qualified_name); Ref<CScript> get_orphan_subclass(const String &p_qualified_name);
GDScriptLanguage(); CScriptLanguage();
~GDScriptLanguage(); ~CScriptLanguage();
}; };
class ResourceFormatLoaderGDScript : public ResourceFormatLoader { class ResourceFormatLoaderCScript : public ResourceFormatLoader {
public: public:
virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr); virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr);
virtual void get_recognized_extensions(List<String> *p_extensions) const; virtual void get_recognized_extensions(List<String> *p_extensions) const;
@ -557,11 +557,11 @@ public:
virtual void get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types = false); virtual void get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types = false);
}; };
class ResourceFormatSaverGDScript : public ResourceFormatSaver { class ResourceFormatSaverCScript : public ResourceFormatSaver {
public: public:
virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0); virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const; virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
virtual bool recognize(const RES &p_resource) const; virtual bool recognize(const RES &p_resource) const;
}; };
#endif // GDSCRIPT_H #endif // CSCRIPT_H

704
modules/cscript/cscript_compiler.cpp
View File

File diff suppressed because it is too large Load Diff

52
modules/cscript/cscript_compiler.h
View File

@ -34,21 +34,21 @@
#include "cscript.h" #include "cscript.h"
#include "cscript_parser.h" #include "cscript_parser.h"
class GDScriptCompiler { class CScriptCompiler {
const GDScriptParser *parser; const CScriptParser *parser;
Set<GDScript *> parsed_classes; Set<CScript *> parsed_classes;
Set<GDScript *> parsing_classes; Set<CScript *> parsing_classes;
GDScript *main_script; CScript *main_script;
struct CodeGen { struct CodeGen {
GDScript *script; CScript *script;
const GDScriptParser::ClassNode *class_node; const CScriptParser::ClassNode *class_node;
const GDScriptParser::FunctionNode *function_node; const CScriptParser::FunctionNode *function_node;
bool debug_stack; bool debug_stack;
List<Map<StringName, int>> stack_id_stack; List<Map<StringName, int>> stack_id_stack;
Map<StringName, int> stack_identifiers; Map<StringName, int> stack_identifiers;
List<GDScriptFunction::StackDebug> stack_debug; List<CScriptFunction::StackDebug> stack_debug;
List<Map<StringName, int>> block_identifier_stack; List<Map<StringName, int>> block_identifier_stack;
Map<StringName, int> block_identifiers; Map<StringName, int> block_identifiers;
@ -56,7 +56,7 @@ class GDScriptCompiler {
stack_identifiers[p_id] = p_stackpos; stack_identifiers[p_id] = p_stackpos;
if (debug_stack) { if (debug_stack) {
block_identifiers[p_id] = p_stackpos; block_identifiers[p_id] = p_stackpos;
GDScriptFunction::StackDebug sd; CScriptFunction::StackDebug sd;
sd.added = true; sd.added = true;
sd.line = current_line; sd.line = current_line;
sd.identifier = p_id; sd.identifier = p_id;
@ -79,7 +79,7 @@ class GDScriptCompiler {
if (debug_stack) { if (debug_stack) {
for (Map<StringName, int>::Element *E = block_identifiers.front(); E; E = E->next()) { for (Map<StringName, int>::Element *E = block_identifiers.front(); E; E = E->next()) {
GDScriptFunction::StackDebug sd; CScriptFunction::StackDebug sd;
sd.added = false; sd.added = false;
sd.identifier = E->key(); sd.identifier = E->key();
sd.line = current_line; sd.line = current_line;
@ -135,35 +135,35 @@ class GDScriptCompiler {
}; };
bool _is_class_member_property(CodeGen &codegen, const StringName &p_name); bool _is_class_member_property(CodeGen &codegen, const StringName &p_name);
bool _is_class_member_property(GDScript *owner, const StringName &p_name); bool _is_class_member_property(CScript *owner, const StringName &p_name);
void _set_error(const String &p_error, const GDScriptParser::Node *p_node); void _set_error(const String &p_error, const CScriptParser::Node *p_node);
bool _create_unary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level); bool _create_unary_operator(CodeGen &codegen, const CScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level);
bool _create_binary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer = false, int p_index_addr = 0); bool _create_binary_operator(CodeGen &codegen, const CScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer = false, int p_index_addr = 0);
GDScriptDataType _gdtype_from_datatype(const GDScriptParser::DataType &p_datatype, GDScript *p_owner = nullptr) const; CScriptDataType _gdtype_from_datatype(const CScriptParser::DataType &p_datatype, CScript *p_owner = nullptr) const;
int _parse_assign_right_expression(CodeGen &codegen, const GDScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr = 0); int _parse_assign_right_expression(CodeGen &codegen, const CScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr = 0);
int _parse_expression(CodeGen &codegen, const GDScriptParser::Node *p_expression, int p_stack_level, bool p_root = false, bool p_initializer = false, int p_index_addr = 0); int _parse_expression(CodeGen &codegen, const CScriptParser::Node *p_expression, int p_stack_level, bool p_root = false, bool p_initializer = false, int p_index_addr = 0);
Error _parse_block(CodeGen &codegen, const GDScriptParser::BlockNode *p_block, int p_stack_level = 0, int p_break_addr = -1, int p_continue_addr = -1); Error _parse_block(CodeGen &codegen, const CScriptParser::BlockNode *p_block, int p_stack_level = 0, int p_break_addr = -1, int p_continue_addr = -1);
Error _parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready = false); Error _parse_function(CScript *p_script, const CScriptParser::ClassNode *p_class, const CScriptParser::FunctionNode *p_func, bool p_for_ready = false);
Error _parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); Error _parse_class_level(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state);
Error _parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); Error _parse_class_blocks(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state);
void _make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state); void _make_scripts(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state);
int err_line; int err_line;
int err_column; int err_column;
StringName source; StringName source;
String error; String error;
public: public:
Error compile(const GDScriptParser *p_parser, GDScript *p_script, bool p_keep_state = false); Error compile(const CScriptParser *p_parser, CScript *p_script, bool p_keep_state = false);
String get_error() const; String get_error() const;
int get_error_line() const; int get_error_line() const;
int get_error_column() const; int get_error_column() const;
GDScriptCompiler(); CScriptCompiler();
}; };
#endif // GDSCRIPT_COMPILER_H #endif // CSCRIPT_COMPILER_H

858
modules/cscript/cscript_editor.cpp
View File

File diff suppressed because it is too large Load Diff

158
modules/cscript/cscript_function.cpp
View File

@ -34,7 +34,7 @@
#include "cscript.h" #include "cscript.h"
#include "cscript_functions.h" #include "cscript_functions.h"
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 { Variant *CScriptFunction::_get_variant(int p_address, CScriptInstance *p_instance, CScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const {
int address = p_address & ADDR_MASK; int address = p_address & ADDR_MASK;
//sequential table (jump table generated by compiler) //sequential table (jump table generated by compiler)
@ -63,14 +63,14 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
} break; } break;
case ADDR_TYPE_CLASS_CONSTANT: { case ADDR_TYPE_CLASS_CONSTANT: {
//todo change to index! //todo change to index!
GDScript *s = p_script; CScript *s = p_script;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
ERR_FAIL_INDEX_V(address, _global_names_count, nullptr); ERR_FAIL_INDEX_V(address, _global_names_count, nullptr);
#endif #endif
const StringName *sn = &_global_names_ptr[address]; const StringName *sn = &_global_names_ptr[address];
while (s) { while (s) {
GDScript *o = s; CScript *o = s;
while (o) { while (o) {
Map<StringName, Variant>::Element *E = o->constants.find(*sn); Map<StringName, Variant>::Element *E = o->constants.find(*sn);
if (E) { if (E) {
@ -81,7 +81,7 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
s = s->_base; s = s->_base;
} }
ERR_FAIL_V_MSG(nullptr, "GDScriptCompiler bug."); ERR_FAIL_V_MSG(nullptr, "CScriptCompiler bug.");
} break; } break;
case ADDR_TYPE_LOCAL_CONSTANT: { case ADDR_TYPE_LOCAL_CONSTANT: {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
@ -98,9 +98,9 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
} break; } break;
case ADDR_TYPE_GLOBAL: { case ADDR_TYPE_GLOBAL: {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
ERR_FAIL_INDEX_V(address, GDScriptLanguage::get_singleton()->get_global_array_size(), nullptr); ERR_FAIL_INDEX_V(address, CScriptLanguage::get_singleton()->get_global_array_size(), nullptr);
#endif #endif
return &GDScriptLanguage::get_singleton()->get_global_array()[address]; return &CScriptLanguage::get_singleton()->get_global_array()[address];
} break; } break;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
case ADDR_TYPE_NAMED_GLOBAL: { case ADDR_TYPE_NAMED_GLOBAL: {
@ -109,8 +109,8 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
#endif #endif
StringName id = _named_globals_ptr[address]; StringName id = _named_globals_ptr[address];
if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(id)) { if (CScriptLanguage::get_singleton()->get_named_globals_map().has(id)) {
return (Variant *)&GDScriptLanguage::get_singleton()->get_named_globals_map()[id]; return (Variant *)&CScriptLanguage::get_singleton()->get_named_globals_map()[id];
} else { } else {
r_error = "Autoload singleton '" + String(id) + "' has been removed."; r_error = "Autoload singleton '" + String(id) + "' has been removed.";
return nullptr; return nullptr;
@ -154,7 +154,7 @@ static String _get_var_type(const Variant *p_var) {
} }
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
String GDScriptFunction::_get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const { String CScriptFunction::_get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const {
String err_text; String err_text;
if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) { if (p_err.error == Variant::CallError::CALL_ERROR_INVALID_ARGUMENT) {
@ -251,7 +251,7 @@ String GDScriptFunction::_get_call_error(const Variant::CallError &p_err, const
#define OPCODE_OUT break #define OPCODE_OUT break
#endif #endif
Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state) { Variant CScriptFunction::call(CScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state) {
OPCODES_TABLE; OPCODES_TABLE;
if (!_code_ptr) { if (!_code_ptr) {
@ -269,12 +269,12 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
//GDScriptLanguage::get_singleton()->calls++; //CScriptLanguage::get_singleton()->calls++;
#endif #endif
uint32_t alloca_size = 0; uint32_t alloca_size = 0;
GDScript *script; CScript *script;
int ip = 0; int ip = 0;
int line = _initial_line; int line = _initial_line;
@ -327,11 +327,11 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
} else { } else {
r_err.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_err.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_err.argument = i; r_err.argument = i;
r_err.expected = argument_types[i].kind == GDScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT; r_err.expected = argument_types[i].kind == CScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT;
return Variant(); return Variant();
} }
} }
if (argument_types[i].kind == GDScriptDataType::BUILTIN) { if (argument_types[i].kind == CScriptDataType::BUILTIN) {
Variant arg = Variant::construct(argument_types[i].builtin_type, &p_args[i], 1, r_err); Variant arg = Variant::construct(argument_types[i].builtin_type, &p_args[i], 1, r_err);
memnew_placement(&stack[i], Variant(arg)); memnew_placement(&stack[i], Variant(arg));
} else { } else {
@ -374,7 +374,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton()) { if (ScriptDebugger::get_singleton()) {
GDScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line); CScriptLanguage::get_singleton()->enter_function(p_instance, this, stack, &ip, &line);
} }
#define GD_ERR_BREAK(m_cond) \ #define GD_ERR_BREAK(m_cond) \
@ -408,7 +408,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
uint64_t function_start_time = 0; uint64_t function_start_time = 0;
uint64_t function_call_time = 0; uint64_t function_call_time = 0;
if (GDScriptLanguage::get_singleton()->profiling) { if (CScriptLanguage::get_singleton()->profiling) {
function_start_time = OS::get_singleton()->get_ticks_usec(); function_start_time = OS::get_singleton()->get_ticks_usec();
function_call_time = 0; function_call_time = 0;
profile.call_count++; profile.call_count++;
@ -484,14 +484,14 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
Object *obj_A = *a; Object *obj_A = *a;
Object *obj_B = *b; Object *obj_B = *b;
GDScript *scr_B = Object::cast_to<GDScript>(obj_B); CScript *scr_B = Object::cast_to<CScript>(obj_B);
if (scr_B) { if (scr_B) {
//if B is a script, the only valid condition is that A has an instance which inherits from the script //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. //in other situation, this shoul return false.
if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) { if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == CScriptLanguage::get_singleton()) {
GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr()); CScript *cmp = static_cast<CScript *>(obj_A->get_script_instance()->get_script().ptr());
//bool found=false; //bool found=false;
while (cmp) { while (cmp) {
if (cmp == scr_B) { if (cmp == scr_B) {
@ -505,7 +505,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
} }
} else { } else {
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(obj_B); CScriptNativeClass *nc = Object::cast_to<CScriptNativeClass>(obj_B);
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (!nc) { if (!nc) {
@ -769,7 +769,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
GET_VARIANT_PTR(type, 1); GET_VARIANT_PTR(type, 1);
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(type->operator Object *()); CScriptNativeClass *nc = Object::cast_to<CScriptNativeClass>(type->operator Object *());
GD_ERR_BREAK(!nc); GD_ERR_BREAK(!nc);
if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) { if (src->get_type() != Variant::OBJECT && src->get_type() != Variant::NIL) {
err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) + err_text = "Trying to assign value of type '" + Variant::get_type_name(src->get_type()) +
@ -871,7 +871,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
GET_VARIANT_PTR(src, 2); GET_VARIANT_PTR(src, 2);
GET_VARIANT_PTR(dst, 3); GET_VARIANT_PTR(dst, 3);
GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(to_type->operator Object *()); CScriptNativeClass *nc = Object::cast_to<CScriptNativeClass>(to_type->operator Object *());
GD_ERR_BREAK(!nc); GD_ERR_BREAK(!nc);
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
@ -1038,7 +1038,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
uint64_t call_time = 0; uint64_t call_time = 0;
if (GDScriptLanguage::get_singleton()->profiling) { if (CScriptLanguage::get_singleton()->profiling) {
call_time = OS::get_singleton()->get_ticks_usec(); call_time = OS::get_singleton()->get_ticks_usec();
} }
@ -1051,7 +1051,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
base->call_ptr(*methodname, (const Variant **)argptrs, argc, nullptr, err); base->call_ptr(*methodname, (const Variant **)argptrs, argc, nullptr, err);
} }
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (GDScriptLanguage::get_singleton()->profiling) { if (CScriptLanguage::get_singleton()->profiling) {
function_call_time += OS::get_singleton()->get_ticks_usec() - call_time; function_call_time += OS::get_singleton()->get_ticks_usec() - call_time;
} }
@ -1097,7 +1097,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
OPCODE(OPCODE_CALL_BUILT_IN) { OPCODE(OPCODE_CALL_BUILT_IN) {
CHECK_SPACE(4); CHECK_SPACE(4);
GDScriptFunctions::Function func = GDScriptFunctions::Function(_code_ptr[ip + 1]); CScriptFunctions::Function func = CScriptFunctions::Function(_code_ptr[ip + 1]);
int argc = _code_ptr[ip + 2]; int argc = _code_ptr[ip + 2];
GD_ERR_BREAK(argc < 0); GD_ERR_BREAK(argc < 0);
@ -1114,11 +1114,11 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
Variant::CallError err; Variant::CallError err;
GDScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err); CScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (err.error != Variant::CallError::CALL_OK) { if (err.error != Variant::CallError::CALL_OK) {
String methodstr = GDScriptFunctions::get_func_name(func); String methodstr = CScriptFunctions::get_func_name(func);
if (dst->get_type() == Variant::STRING) { if (dst->get_type() == Variant::STRING) {
//call provided error string //call provided error string
err_text = "Error calling built-in function '" + methodstr + "': " + String(*dst); err_text = "Error calling built-in function '" + methodstr + "': " + String(*dst);
@ -1161,9 +1161,9 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
GET_VARIANT_PTR(dst, argc + 3); GET_VARIANT_PTR(dst, argc + 3);
const GDScript *gds = _script; const CScript *gds = _script;
const Map<StringName, GDScriptFunction *>::Element *E = nullptr; const Map<StringName, CScriptFunction *>::Element *E = nullptr;
while (gds->base.ptr()) { while (gds->base.ptr()) {
gds = gds->base.ptr(); gds = gds->base.ptr();
E = gds->member_functions.find(*methodname); E = gds->member_functions.find(*methodname);
@ -1177,7 +1177,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
if (E) { if (E) {
*dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err); *dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err);
} else if (gds->native.ptr()) { } else if (gds->native.ptr()) {
if (*methodname != GDScriptLanguage::get_singleton()->strings._init) { if (*methodname != CScriptLanguage::get_singleton()->strings._init) {
MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname); MethodBind *mb = ClassDB::get_method(gds->native->get_name(), *methodname);
if (!mb) { if (!mb) {
err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD; err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
@ -1188,7 +1188,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
err.error = Variant::CallError::CALL_OK; err.error = Variant::CallError::CALL_OK;
} }
} else { } else {
if (*methodname != GDScriptLanguage::get_singleton()->strings._init) { if (*methodname != CScriptLanguage::get_singleton()->strings._init) {
err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD; err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
} else { } else {
err.error = Variant::CallError::CALL_OK; err.error = Variant::CallError::CALL_OK;
@ -1216,7 +1216,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
CHECK_SPACE(2); CHECK_SPACE(2);
} }
Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState); Ref<CScriptFunctionState> gdfs = memnew(CScriptFunctionState);
gdfs->function = this; gdfs->function = this;
gdfs->state.stack.resize(alloca_size); gdfs->state.stack.resize(alloca_size);
@ -1230,7 +1230,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
gdfs->state.ip = ip + ipofs; gdfs->state.ip = ip + ipofs;
gdfs->state.line = line; gdfs->state.line = line;
gdfs->state.script = _script; gdfs->state.script = _script;
GDScriptLanguage::singleton->lock.lock(); CScriptLanguage::singleton->lock.lock();
_script->pending_func_states.add(&gdfs->scripts_list); _script->pending_func_states.add(&gdfs->scripts_list);
if (p_instance) { if (p_instance) {
@ -1239,7 +1239,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
} else { } else {
gdfs->state.instance = nullptr; gdfs->state.instance = nullptr;
} }
GDScriptLanguage::singleton->lock.unlock(); CScriptLanguage::singleton->lock.unlock();
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
gdfs->state.function_name = name; gdfs->state.function_name = name;
gdfs->state.script_path = _script->get_path(); gdfs->state.script_path = _script->get_path();
@ -1466,7 +1466,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
OPCODE(OPCODE_BREAKPOINT) { OPCODE(OPCODE_BREAKPOINT) {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton()) { if (ScriptDebugger::get_singleton()) {
GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true); CScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
} }
#endif #endif
ip += 1; ip += 1;
@ -1497,7 +1497,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
} }
if (do_break) { if (do_break) {
GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true); CScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
} }
ScriptDebugger::get_singleton()->line_poll(); ScriptDebugger::get_singleton()->line_poll();
@ -1545,7 +1545,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
err_text = "Internal script error! Opcode: " + itos(last_opcode) + " (please report)."; err_text = "Internal script error! Opcode: " + itos(last_opcode) + " (please report).";
} }
if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) { if (!CScriptLanguage::get_singleton()->debug_break(err_text, false)) {
// debugger break did not happen // debugger break did not happen
_err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), ERR_HANDLER_SCRIPT); _err_print_error(err_func.utf8().get_data(), err_file.utf8().get_data(), err_line, err_text.utf8().get_data(), ERR_HANDLER_SCRIPT);
@ -1557,13 +1557,13 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
OPCODES_OUT OPCODES_OUT
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (GDScriptLanguage::get_singleton()->profiling) { if (CScriptLanguage::get_singleton()->profiling) {
uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time; uint64_t time_taken = OS::get_singleton()->get_ticks_usec() - function_start_time;
profile.total_time += time_taken; profile.total_time += time_taken;
profile.self_time += time_taken - function_call_time; profile.self_time += time_taken - function_call_time;
profile.frame_total_time += time_taken; profile.frame_total_time += time_taken;
profile.frame_self_time += time_taken - function_call_time; profile.frame_self_time += time_taken - function_call_time;
GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time; CScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
} }
// Check if this is the last time the function is resuming from yield // Check if this is the last time the function is resuming from yield
@ -1572,7 +1572,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
// so the debugger knows which function triggered the resume of the next function (if any) // so the debugger knows which function triggered the resume of the next function (if any)
if (!p_state || yielded) { if (!p_state || yielded) {
if (ScriptDebugger::get_singleton()) { if (ScriptDebugger::get_singleton()) {
GDScriptLanguage::get_singleton()->exit_function(); CScriptLanguage::get_singleton()->exit_function();
} }
#endif #endif
@ -1590,45 +1590,45 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
return retvalue; return retvalue;
} }
const int *GDScriptFunction::get_code() const { const int *CScriptFunction::get_code() const {
return _code_ptr; return _code_ptr;
} }
int GDScriptFunction::get_code_size() const { int CScriptFunction::get_code_size() const {
return _code_size; return _code_size;
} }
Variant GDScriptFunction::get_constant(int p_idx) const { Variant CScriptFunction::get_constant(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>"); ERR_FAIL_INDEX_V(p_idx, constants.size(), "<errconst>");
return constants[p_idx]; return constants[p_idx];
} }
StringName GDScriptFunction::get_global_name(int p_idx) const { StringName CScriptFunction::get_global_name(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, global_names.size(), "<errgname>"); ERR_FAIL_INDEX_V(p_idx, global_names.size(), "<errgname>");
return global_names[p_idx]; return global_names[p_idx];
} }
int GDScriptFunction::get_default_argument_count() const { int CScriptFunction::get_default_argument_count() const {
return _default_arg_count; return _default_arg_count;
} }
int GDScriptFunction::get_default_argument_addr(int p_idx) const { int CScriptFunction::get_default_argument_addr(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), -1); ERR_FAIL_INDEX_V(p_idx, default_arguments.size(), -1);
return default_arguments[p_idx]; return default_arguments[p_idx];
} }
GDScriptDataType GDScriptFunction::get_return_type() const { CScriptDataType CScriptFunction::get_return_type() const {
return return_type; return return_type;
} }
GDScriptDataType GDScriptFunction::get_argument_type(int p_idx) const { CScriptDataType CScriptFunction::get_argument_type(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, argument_types.size(), GDScriptDataType()); ERR_FAIL_INDEX_V(p_idx, argument_types.size(), CScriptDataType());
return argument_types[p_idx]; return argument_types[p_idx];
} }
StringName GDScriptFunction::get_name() const { StringName CScriptFunction::get_name() const {
return name; return name;
} }
int GDScriptFunction::get_max_stack_size() const { int CScriptFunction::get_max_stack_size() const {
return _stack_size; return _stack_size;
} }
@ -1647,7 +1647,7 @@ struct _GDFKCS {
} }
}; };
void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const { void CScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<StringName, int>> *r_stackvars) const {
int oc = 0; int oc = 0;
Map<StringName, _GDFKC> sdmap; Map<StringName, _GDFKC> sdmap;
for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) { for (const List<StackDebug>::Element *E = stack_debug.front(); E; E = E->next()) {
@ -1695,7 +1695,7 @@ void GDScriptFunction::debug_get_stack_member_state(int p_line, List<Pair<String
} }
} }
GDScriptFunction::GDScriptFunction() : CScriptFunction::CScriptFunction() :
function_list(this) { function_list(this) {
_stack_size = 0; _stack_size = 0;
_call_size = 0; _call_size = 0;
@ -1704,9 +1704,9 @@ GDScriptFunction::GDScriptFunction() :
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
_func_cname = nullptr; _func_cname = nullptr;
GDScriptLanguage::get_singleton()->lock.lock(); CScriptLanguage::get_singleton()->lock.lock();
GDScriptLanguage::get_singleton()->function_list.add(&function_list); CScriptLanguage::get_singleton()->function_list.add(&function_list);
GDScriptLanguage::get_singleton()->lock.unlock(); CScriptLanguage::get_singleton()->lock.unlock();
profile.call_count = 0; profile.call_count = 0;
profile.self_time = 0; profile.self_time = 0;
@ -1721,17 +1721,17 @@ GDScriptFunction::GDScriptFunction() :
#endif #endif
} }
GDScriptFunction::~GDScriptFunction() { CScriptFunction::~CScriptFunction() {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
GDScriptLanguage::get_singleton()->lock.lock(); CScriptLanguage::get_singleton()->lock.lock();
GDScriptLanguage::get_singleton()->function_list.remove(&function_list); CScriptLanguage::get_singleton()->function_list.remove(&function_list);
GDScriptLanguage::get_singleton()->lock.unlock(); CScriptLanguage::get_singleton()->lock.unlock();
#endif #endif
} }
///////////////////// /////////////////////
Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error) { Variant CScriptFunctionState::_signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
Variant arg; Variant arg;
r_error.error = Variant::CallError::CALL_OK; r_error.error = Variant::CallError::CALL_OK;
@ -1751,7 +1751,7 @@ Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_ar
arg = extra_args; arg = extra_args;
} }
Ref<GDScriptFunctionState> self = *p_args[p_argcount - 1]; Ref<CScriptFunctionState> self = *p_args[p_argcount - 1];
if (self.is_null()) { if (self.is_null()) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
@ -1763,14 +1763,14 @@ Variant GDScriptFunctionState::_signal_callback(const Variant **p_args, int p_ar
return resume(arg); return resume(arg);
} }
bool GDScriptFunctionState::is_valid(bool p_extended_check) const { bool CScriptFunctionState::is_valid(bool p_extended_check) const {
if (function == nullptr) { if (function == nullptr) {
return false; return false;
} }
if (p_extended_check) { if (p_extended_check) {
#ifndef NO_THREADS #ifndef NO_THREADS
MutexLock lock(GDScriptLanguage::get_singleton()->lock); MutexLock lock(CScriptLanguage::get_singleton()->lock);
#endif #endif
// Script gone? // Script gone?
if (!scripts_list.in_list()) { if (!scripts_list.in_list()) {
@ -1785,11 +1785,11 @@ bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
return true; return true;
} }
Variant GDScriptFunctionState::resume(const Variant &p_arg) { Variant CScriptFunctionState::resume(const Variant &p_arg) {
ERR_FAIL_COND_V(!function, Variant()); ERR_FAIL_COND_V(!function, Variant());
{ {
#ifndef NO_THREADS #ifndef NO_THREADS
MutexLock lock(GDScriptLanguage::singleton->lock); MutexLock lock(CScriptLanguage::singleton->lock);
#endif #endif
if (!scripts_list.in_list()) { if (!scripts_list.in_list()) {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
@ -1816,13 +1816,13 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
bool completed = true; bool completed = true;
// If the return value is a GDScriptFunctionState reference, // If the return value is a CScriptFunctionState reference,
// then the function did yield again after resuming. // then the function did yield again after resuming.
if (ret.is_ref()) { if (ret.is_ref()) {
GDScriptFunctionState *gdfs = Object::cast_to<GDScriptFunctionState>(ret); CScriptFunctionState *gdfs = Object::cast_to<CScriptFunctionState>(ret);
if (gdfs && gdfs->function == function) { if (gdfs && gdfs->function == function) {
completed = false; completed = false;
gdfs->first_state = first_state.is_valid() ? first_state : Ref<GDScriptFunctionState>(this); gdfs->first_state = first_state.is_valid() ? first_state : Ref<CScriptFunctionState>(this);
} }
} }
@ -1838,7 +1838,7 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
if (ScriptDebugger::get_singleton()) { if (ScriptDebugger::get_singleton()) {
GDScriptLanguage::get_singleton()->exit_function(); CScriptLanguage::get_singleton()->exit_function();
} }
#endif #endif
} }
@ -1846,7 +1846,7 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
return ret; return ret;
} }
void GDScriptFunctionState::_clear_stack() { void CScriptFunctionState::_clear_stack() {
if (state.stack_size) { if (state.stack_size) {
Variant *stack = (Variant *)state.stack.ptr(); Variant *stack = (Variant *)state.stack.ptr();
for (int i = 0; i < state.stack_size; i++) { for (int i = 0; i < state.stack_size; i++) {
@ -1856,24 +1856,24 @@ void GDScriptFunctionState::_clear_stack() {
} }
} }
void GDScriptFunctionState::_bind_methods() { void CScriptFunctionState::_bind_methods() {
ClassDB::bind_method(D_METHOD("resume", "arg"), &GDScriptFunctionState::resume, DEFVAL(Variant())); ClassDB::bind_method(D_METHOD("resume", "arg"), &CScriptFunctionState::resume, DEFVAL(Variant()));
ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDScriptFunctionState::is_valid, DEFVAL(false)); ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &CScriptFunctionState::is_valid, DEFVAL(false));
ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDScriptFunctionState::_signal_callback, MethodInfo("_signal_callback")); ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &CScriptFunctionState::_signal_callback, MethodInfo("_signal_callback"));
ADD_SIGNAL(MethodInfo("completed", PropertyInfo(Variant::NIL, "result", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT))); ADD_SIGNAL(MethodInfo("completed", PropertyInfo(Variant::NIL, "result", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
} }
GDScriptFunctionState::GDScriptFunctionState() : CScriptFunctionState::CScriptFunctionState() :
scripts_list(this), scripts_list(this),
instances_list(this) { instances_list(this) {
function = nullptr; function = nullptr;
} }
GDScriptFunctionState::~GDScriptFunctionState() { CScriptFunctionState::~CScriptFunctionState() {
_clear_stack(); _clear_stack();
GDScriptLanguage::singleton->lock.lock(); CScriptLanguage::singleton->lock.lock();
scripts_list.remove_from_list(); scripts_list.remove_from_list();
instances_list.remove_from_list(); instances_list.remove_from_list();
GDScriptLanguage::singleton->lock.unlock(); CScriptLanguage::singleton->lock.unlock();
} }

68
modules/cscript/cscript_function.h
View File

@ -38,17 +38,17 @@
#include "core/string_name.h" #include "core/string_name.h"
#include "core/variant.h" #include "core/variant.h"
class GDScriptInstance; class CScriptInstance;
class GDScript; class CScript;
struct GDScriptDataType { struct CScriptDataType {
bool has_type; bool has_type;
enum { enum {
UNINITIALIZED, UNINITIALIZED,
BUILTIN, BUILTIN,
NATIVE, NATIVE,
SCRIPT, SCRIPT,
GDSCRIPT, CSCRIPT,
} kind; } kind;
Variant::Type builtin_type; Variant::Type builtin_type;
StringName native_type; StringName native_type;
@ -94,7 +94,7 @@ struct GDScriptDataType {
return true; return true;
} break; } break;
case SCRIPT: case SCRIPT:
case GDSCRIPT: { case CSCRIPT: {
if (p_variant.get_type() == Variant::NIL) { if (p_variant.get_type() == Variant::NIL) {
return true; return true;
} }
@ -136,7 +136,7 @@ struct GDScriptDataType {
info.class_name = native_type; info.class_name = native_type;
} break; } break;
case SCRIPT: case SCRIPT:
case GDSCRIPT: { case CSCRIPT: {
info.type = Variant::OBJECT; info.type = Variant::OBJECT;
info.class_name = script_type->get_instance_base_type(); info.class_name = script_type->get_instance_base_type();
} break; } break;
@ -148,14 +148,14 @@ struct GDScriptDataType {
return info; return info;
} }
GDScriptDataType() : CScriptDataType() :
has_type(false), has_type(false),
kind(UNINITIALIZED), kind(UNINITIALIZED),
builtin_type(Variant::NIL), builtin_type(Variant::NIL),
script_type(nullptr) {} script_type(nullptr) {}
}; };
class GDScriptFunction { class CScriptFunction {
public: public:
enum Opcode { enum Opcode {
OPCODE_OPERATOR, OPCODE_OPERATOR,
@ -224,7 +224,7 @@ public:
}; };
private: private:
friend class GDScriptCompiler; friend class CScriptCompiler;
StringName source; StringName source;
@ -248,7 +248,7 @@ private:
bool _static; bool _static;
MultiplayerAPI::RPCMode rpc_mode; MultiplayerAPI::RPCMode rpc_mode;
GDScript *_script; CScript *_script;
StringName name; StringName name;
Vector<Variant> constants; Vector<Variant> constants;
@ -258,8 +258,8 @@ private:
#endif #endif
Vector<int> default_arguments; Vector<int> default_arguments;
Vector<int> code; Vector<int> code;
Vector<GDScriptDataType> argument_types; Vector<CScriptDataType> argument_types;
GDScriptDataType return_type; CScriptDataType return_type;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
Vector<StringName> arg_names; Vector<StringName> arg_names;
@ -267,12 +267,12 @@ private:
List<StackDebug> stack_debug; List<StackDebug> stack_debug;
_FORCE_INLINE_ Variant *_get_variant(int p_address, GDScriptInstance *p_instance, GDScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const; _FORCE_INLINE_ Variant *_get_variant(int p_address, CScriptInstance *p_instance, CScript *p_script, Variant &self, Variant &static_ref, Variant *p_stack, String &r_error) const;
_FORCE_INLINE_ String _get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const; _FORCE_INLINE_ String _get_call_error(const Variant::CallError &p_err, const String &p_where, const Variant **argptrs) const;
friend class GDScriptLanguage; friend class CScriptLanguage;
SelfList<GDScriptFunction> function_list; SelfList<CScriptFunction> function_list;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
CharString func_cname; CharString func_cname;
const char *_func_cname; const char *_func_cname;
@ -294,8 +294,8 @@ private:
public: public:
struct CallState { struct CallState {
GDScript *script; CScript *script;
GDScriptInstance *instance; CScriptInstance *instance;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
StringName function_name; StringName function_name;
String script_path; String script_path;
@ -322,9 +322,9 @@ public:
int get_max_stack_size() const; int get_max_stack_size() const;
int get_default_argument_count() const; int get_default_argument_count() const;
int get_default_argument_addr(int p_idx) const; int get_default_argument_addr(int p_idx) const;
GDScriptDataType get_return_type() const; CScriptDataType get_return_type() const;
GDScriptDataType get_argument_type(int p_idx) const; CScriptDataType get_argument_type(int p_idx) const;
GDScript *get_script() const { CScript *get_script() const {
return _script; return _script;
} }
StringName get_source() const { StringName get_source() const {
@ -353,25 +353,25 @@ public:
return default_arguments[p_idx]; return default_arguments[p_idx];
} }
Variant call(GDScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state = nullptr); Variant call(CScriptInstance *p_instance, const Variant **p_args, int p_argcount, Variant::CallError &r_err, CallState *p_state = nullptr);
_FORCE_INLINE_ MultiplayerAPI::RPCMode get_rpc_mode() const { _FORCE_INLINE_ MultiplayerAPI::RPCMode get_rpc_mode() const {
return rpc_mode; return rpc_mode;
} }
GDScriptFunction(); CScriptFunction();
~GDScriptFunction(); ~CScriptFunction();
}; };
class GDScriptFunctionState : public Reference { class CScriptFunctionState : public Reference {
GDCLASS(GDScriptFunctionState, Reference); GDCLASS(CScriptFunctionState, Reference);
friend class GDScriptFunction; friend class CScriptFunction;
GDScriptFunction *function; CScriptFunction *function;
GDScriptFunction::CallState state; CScriptFunction::CallState state;
Variant _signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error); Variant _signal_callback(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
Ref<GDScriptFunctionState> first_state; Ref<CScriptFunctionState> first_state;
SelfList<GDScriptFunctionState> scripts_list; SelfList<CScriptFunctionState> scripts_list;
SelfList<GDScriptFunctionState> instances_list; SelfList<CScriptFunctionState> instances_list;
protected: protected:
static void _bind_methods(); static void _bind_methods();
@ -382,8 +382,8 @@ public:
void _clear_stack(); void _clear_stack();
GDScriptFunctionState(); CScriptFunctionState();
~GDScriptFunctionState(); ~CScriptFunctionState();
}; };
#endif // GDSCRIPT_FUNCTION_H #endif // CSCRIPT_FUNCTION_H

34
modules/cscript/cscript_functions.cpp
View File

@ -40,7 +40,7 @@
#include "core/variant_parser.h" #include "core/variant_parser.h"
#include "cscript.h" #include "cscript.h"
const char *GDScriptFunctions::get_func_name(Function p_func) { const char *CScriptFunctions::get_func_name(Function p_func) {
ERR_FAIL_INDEX_V(p_func, FUNC_MAX, ""); ERR_FAIL_INDEX_V(p_func, FUNC_MAX, "");
static const char *_names[FUNC_MAX] = { static const char *_names[FUNC_MAX] = {
@ -140,7 +140,7 @@ const char *GDScriptFunctions::get_func_name(Function p_func) {
return _names[p_func]; return _names[p_func];
} }
void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) { void CScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_count, Variant &r_ret, Variant::CallError &r_error) {
r_error.error = Variant::CallError::CALL_OK; r_error.error = Variant::CallError::CALL_OK;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
@ -342,7 +342,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
VALIDATE_ARG_COUNT(1); VALIDATE_ARG_COUNT(1);
VALIDATE_ARG_NUM(0); VALIDATE_ARG_NUM(0);
r_ret = Math::step_decimals((double)*p_args[0]); r_ret = Math::step_decimals((double)*p_args[0]);
WARN_DEPRECATED_MSG("GDScript method 'decimals' is deprecated and has been renamed to 'step_decimals', please update your code accordingly."); WARN_DEPRECATED_MSG("CScript method 'decimals' is deprecated and has been renamed to 'step_decimals', please update your code accordingly.");
} break; } break;
case MATH_STEP_DECIMALS: { case MATH_STEP_DECIMALS: {
VALIDATE_ARG_COUNT(1); VALIDATE_ARG_COUNT(1);
@ -753,7 +753,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
str += p_args[i]->operator String(); str += p_args[i]->operator String();
} }
ScriptLanguage *script = GDScriptLanguage::get_singleton(); ScriptLanguage *script = CScriptLanguage::get_singleton();
if (script->debug_get_stack_level_count() > 0) { if (script->debug_get_stack_level_count() > 0) {
str += "\n At: " + script->debug_get_stack_level_source(0) + ":" + itos(script->debug_get_stack_level_line(0)) + ":" + script->debug_get_stack_level_function(0) + "()"; str += "\n At: " + script->debug_get_stack_level_source(0) + ":" + itos(script->debug_get_stack_level_line(0)) + ":" + script->debug_get_stack_level_function(0) + "()";
} }
@ -1041,15 +1041,15 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
if (!obj) { if (!obj) {
r_ret = Variant(); r_ret = Variant();
} else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != GDScriptLanguage::get_singleton()) { } else if (!obj->get_script_instance() || obj->get_script_instance()->get_language() != CScriptLanguage::get_singleton()) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 0; r_error.argument = 0;
r_error.expected = Variant::DICTIONARY; r_error.expected = Variant::DICTIONARY;
r_ret = RTR("Not a script with an instance"); r_ret = RTR("Not a script with an instance");
return; return;
} else { } else {
GDScriptInstance *ins = static_cast<GDScriptInstance *>(obj->get_script_instance()); CScriptInstance *ins = static_cast<CScriptInstance *>(obj->get_script_instance());
Ref<GDScript> base = ins->get_script(); Ref<CScript> base = ins->get_script();
if (base.is_null()) { if (base.is_null()) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 0; r_error.argument = 0;
@ -1058,7 +1058,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
return; return;
} }
GDScript *p = base.ptr(); CScript *p = base.ptr();
Vector<StringName> sname; Vector<StringName> sname;
while (p->_owner) { while (p->_owner) {
@ -1084,7 +1084,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
d["@subpath"] = cp; d["@subpath"] = cp;
d["@path"] = p->get_path(); d["@path"] = p->get_path();
for (Map<StringName, GDScript::MemberInfo>::Element *E = base->member_indices.front(); E; E = E->next()) { for (Map<StringName, CScript::MemberInfo>::Element *E = base->member_indices.front(); E; E = E->next()) {
if (!d.has(E->key())) { if (!d.has(E->key())) {
d[E->key()] = ins->members[E->get().index]; d[E->key()] = ins->members[E->get().index];
} }
@ -1126,7 +1126,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
return; return;
} }
Ref<GDScript> gdscr = scr; Ref<CScript> gdscr = scr;
if (!gdscr.is_valid()) { if (!gdscr.is_valid()) {
r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT; r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
@ -1161,10 +1161,10 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
return; return;
} }
GDScriptInstance *ins = static_cast<GDScriptInstance *>(static_cast<Object *>(r_ret)->get_script_instance()); CScriptInstance *ins = static_cast<CScriptInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
Ref<GDScript> gd_ref = ins->get_script(); Ref<CScript> gd_ref = ins->get_script();
for (Map<StringName, GDScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) { for (Map<StringName, CScript::MemberInfo>::Element *E = gd_ref->member_indices.front(); E; E = E->next()) {
if (d.has(E->key())) { if (d.has(E->key())) {
ins->members.write[E->get().index] = d[E->key()]; ins->members.write[E->get().index] = d[E->key()];
} }
@ -1289,7 +1289,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
case PRINT_STACK: { case PRINT_STACK: {
VALIDATE_ARG_COUNT(0); VALIDATE_ARG_COUNT(0);
ScriptLanguage *script = GDScriptLanguage::get_singleton(); ScriptLanguage *script = CScriptLanguage::get_singleton();
for (int i = 0; i < script->debug_get_stack_level_count(); i++) { for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'"); print_line("Frame " + itos(i) + " - " + script->debug_get_stack_level_source(i) + ":" + itos(script->debug_get_stack_level_line(i)) + " in function '" + script->debug_get_stack_level_function(i) + "'");
}; };
@ -1298,7 +1298,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
case GET_STACK: { case GET_STACK: {
VALIDATE_ARG_COUNT(0); VALIDATE_ARG_COUNT(0);
ScriptLanguage *script = GDScriptLanguage::get_singleton(); ScriptLanguage *script = CScriptLanguage::get_singleton();
Array ret; Array ret;
for (int i = 0; i < script->debug_get_stack_level_count(); i++) { for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
Dictionary frame; Dictionary frame;
@ -1405,7 +1405,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
} }
} }
bool GDScriptFunctions::is_deterministic(Function p_func) { bool CScriptFunctions::is_deterministic(Function p_func) {
//man i couldn't have chosen a worse function name, //man i couldn't have chosen a worse function name,
//way too controversial.. //way too controversial..
@ -1473,7 +1473,7 @@ bool GDScriptFunctions::is_deterministic(Function p_func) {
return false; return false;
} }
MethodInfo GDScriptFunctions::get_info(Function p_func) { MethodInfo CScriptFunctions::get_info(Function p_func) {
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
//using a switch, so the compiler generates a jumptable //using a switch, so the compiler generates a jumptable

4
modules/cscript/cscript_functions.h
View File

@ -32,7 +32,7 @@
#include "core/variant.h" #include "core/variant.h"
class GDScriptFunctions { class CScriptFunctions {
public: public:
enum Function { enum Function {
MATH_SIN, MATH_SIN,
@ -135,4 +135,4 @@ public:
static MethodInfo get_info(Function p_func); static MethodInfo get_info(Function p_func);
}; };
#endif // GDSCRIPT_FUNCTIONS_H #endif // CSCRIPT_FUNCTIONS_H

1154
modules/cscript/cscript_parser.cpp
View File

File diff suppressed because it is too large Load Diff

26
modules/cscript/cscript_parser.h
View File

@ -36,10 +36,10 @@
#include "cscript_functions.h" #include "cscript_functions.h"
#include "cscript_tokenizer.h" #include "cscript_tokenizer.h"
struct GDScriptDataType; struct CScriptDataType;
struct GDScriptWarning; struct CScriptWarning;
class GDScriptParser { class CScriptParser {
public: public:
struct ClassNode; struct ClassNode;
@ -48,7 +48,7 @@ public:
BUILTIN, BUILTIN,
NATIVE, NATIVE,
SCRIPT, SCRIPT,
GDSCRIPT, CSCRIPT,
CLASS, CLASS,
UNRESOLVED UNRESOLVED
} kind; } kind;
@ -80,7 +80,7 @@ public:
case NATIVE: { case NATIVE: {
return native_type == other.native_type; return native_type == other.native_type;
} break; } break;
case GDSCRIPT: case CSCRIPT:
case SCRIPT: { case SCRIPT: {
return script_type == other.script_type; return script_type == other.script_type;
} break; } break;
@ -264,7 +264,7 @@ public:
TypeNode() { type = TYPE_TYPE; } TypeNode() { type = TYPE_TYPE; }
}; };
struct BuiltInFunctionNode : public Node { struct BuiltInFunctionNode : public Node {
GDScriptFunctions::Function function; CScriptFunctions::Function function;
BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; } BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; }
}; };
@ -520,7 +520,7 @@ public:
}; };
private: private:
GDScriptTokenizer *tokenizer; CScriptTokenizer *tokenizer;
Node *head; Node *head;
Node *list; Node *list;
@ -542,7 +542,7 @@ private:
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
List<GDScriptWarning> warnings; List<CScriptWarning> warnings;
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
int pending_newline; int pending_newline;
@ -626,7 +626,7 @@ private:
DataType _resolve_type(const DataType &p_source, int p_line); DataType _resolve_type(const DataType &p_source, int p_line);
DataType _type_from_variant(const Variant &p_value) const; DataType _type_from_variant(const Variant &p_value) const;
DataType _type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant = true) const; DataType _type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant = true) const;
DataType _type_from_gdtype(const GDScriptDataType &p_gdtype) const; DataType _type_from_gdtype(const CScriptDataType &p_gdtype) const;
DataType _get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const; DataType _get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const;
Variant::Operator _get_variant_operation(const OperatorNode::Operator &p_op) const; Variant::Operator _get_variant_operation(const OperatorNode::Operator &p_op) const;
bool _get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const; bool _get_function_signature(DataType &p_base_type, const StringName &p_function, DataType &r_return_type, List<DataType> &r_arg_types, int &r_default_arg_count, bool &r_static, bool &r_vararg) const;
@ -664,7 +664,7 @@ public:
int get_error_line() const; int get_error_line() const;
int get_error_column() const; int get_error_column() const;
#ifdef DEBUG_ENABLED #ifdef DEBUG_ENABLED
const List<GDScriptWarning> &get_warnings() const { const List<CScriptWarning> &get_warnings() const {
return warnings; return warnings;
} }
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
@ -692,8 +692,8 @@ public:
} }
void clear(); void clear();
GDScriptParser(); CScriptParser();
~GDScriptParser(); ~CScriptParser();
}; };
#endif // GDSCRIPT_PARSER_H #endif // CSCRIPT_PARSER_H

196
modules/cscript/cscript_tokenizer.cpp
View File

@ -35,7 +35,7 @@
#include "core/print_string.h" #include "core/print_string.h"
#include "cscript_functions.h" #include "cscript_functions.h"
const char *GDScriptTokenizer::token_names[TK_MAX] = { const char *CScriptTokenizer::token_names[TK_MAX] = {
"Empty", "Empty",
"Identifier", "Identifier",
"Constant", "Constant",
@ -182,71 +182,71 @@ static const _bit _type_list[] = {
}; };
struct _kws { struct _kws {
GDScriptTokenizer::Token token; CScriptTokenizer::Token token;
const char *text; const char *text;
}; };
static const _kws _keyword_list[] = { static const _kws _keyword_list[] = {
//ops //ops
{ GDScriptTokenizer::TK_OP_IN, "in" }, { CScriptTokenizer::TK_OP_IN, "in" },
{ GDScriptTokenizer::TK_OP_NOT, "not" }, { CScriptTokenizer::TK_OP_NOT, "not" },
{ GDScriptTokenizer::TK_OP_OR, "or" }, { CScriptTokenizer::TK_OP_OR, "or" },
{ GDScriptTokenizer::TK_OP_AND, "and" }, { CScriptTokenizer::TK_OP_AND, "and" },
//func //func
{ GDScriptTokenizer::TK_PR_FUNCTION, "func" }, { CScriptTokenizer::TK_PR_FUNCTION, "func" },
{ GDScriptTokenizer::TK_PR_CLASS, "class" }, { CScriptTokenizer::TK_PR_CLASS, "class" },
{ GDScriptTokenizer::TK_PR_CLASS_NAME, "class_name" }, { CScriptTokenizer::TK_PR_CLASS_NAME, "class_name" },
{ GDScriptTokenizer::TK_PR_EXTENDS, "extends" }, { CScriptTokenizer::TK_PR_EXTENDS, "extends" },
{ GDScriptTokenizer::TK_PR_IS, "is" }, { CScriptTokenizer::TK_PR_IS, "is" },
{ GDScriptTokenizer::TK_PR_ONREADY, "onready" }, { CScriptTokenizer::TK_PR_ONREADY, "onready" },
{ GDScriptTokenizer::TK_PR_TOOL, "tool" }, { CScriptTokenizer::TK_PR_TOOL, "tool" },
{ GDScriptTokenizer::TK_PR_STATIC, "static" }, { CScriptTokenizer::TK_PR_STATIC, "static" },
{ GDScriptTokenizer::TK_PR_EXPORT, "export" }, { CScriptTokenizer::TK_PR_EXPORT, "export" },
{ GDScriptTokenizer::TK_PR_SETGET, "setget" }, { CScriptTokenizer::TK_PR_SETGET, "setget" },
{ GDScriptTokenizer::TK_PR_VAR, "var" }, { CScriptTokenizer::TK_PR_VAR, "var" },
{ GDScriptTokenizer::TK_PR_AS, "as" }, { CScriptTokenizer::TK_PR_AS, "as" },
{ GDScriptTokenizer::TK_PR_VOID, "void" }, { CScriptTokenizer::TK_PR_VOID, "void" },
{ GDScriptTokenizer::TK_PR_PRELOAD, "preload" }, { CScriptTokenizer::TK_PR_PRELOAD, "preload" },
{ GDScriptTokenizer::TK_PR_ASSERT, "assert" }, { CScriptTokenizer::TK_PR_ASSERT, "assert" },
{ GDScriptTokenizer::TK_PR_YIELD, "yield" }, { CScriptTokenizer::TK_PR_YIELD, "yield" },
{ GDScriptTokenizer::TK_PR_SIGNAL, "signal" }, { CScriptTokenizer::TK_PR_SIGNAL, "signal" },
{ GDScriptTokenizer::TK_PR_BREAKPOINT, "breakpoint" }, { CScriptTokenizer::TK_PR_BREAKPOINT, "breakpoint" },
{ GDScriptTokenizer::TK_PR_REMOTE, "remote" }, { CScriptTokenizer::TK_PR_REMOTE, "remote" },
{ GDScriptTokenizer::TK_PR_MASTER, "master" }, { CScriptTokenizer::TK_PR_MASTER, "master" },
{ GDScriptTokenizer::TK_PR_SLAVE, "slave" }, { CScriptTokenizer::TK_PR_SLAVE, "slave" },
{ GDScriptTokenizer::TK_PR_PUPPET, "puppet" }, { CScriptTokenizer::TK_PR_PUPPET, "puppet" },
{ GDScriptTokenizer::TK_PR_SYNC, "sync" }, { CScriptTokenizer::TK_PR_SYNC, "sync" },
{ GDScriptTokenizer::TK_PR_REMOTESYNC, "remotesync" }, { CScriptTokenizer::TK_PR_REMOTESYNC, "remotesync" },
{ GDScriptTokenizer::TK_PR_MASTERSYNC, "mastersync" }, { CScriptTokenizer::TK_PR_MASTERSYNC, "mastersync" },
{ GDScriptTokenizer::TK_PR_PUPPETSYNC, "puppetsync" }, { CScriptTokenizer::TK_PR_PUPPETSYNC, "puppetsync" },
{ GDScriptTokenizer::TK_PR_CONST, "const" }, { CScriptTokenizer::TK_PR_CONST, "const" },
{ GDScriptTokenizer::TK_PR_ENUM, "enum" }, { CScriptTokenizer::TK_PR_ENUM, "enum" },
//controlflow //controlflow
{ GDScriptTokenizer::TK_CF_IF, "if" }, { CScriptTokenizer::TK_CF_IF, "if" },
{ GDScriptTokenizer::TK_CF_ELIF, "elif" }, { CScriptTokenizer::TK_CF_ELIF, "elif" },
{ GDScriptTokenizer::TK_CF_ELSE, "else" }, { CScriptTokenizer::TK_CF_ELSE, "else" },
{ GDScriptTokenizer::TK_CF_FOR, "for" }, { CScriptTokenizer::TK_CF_FOR, "for" },
{ GDScriptTokenizer::TK_CF_WHILE, "while" }, { CScriptTokenizer::TK_CF_WHILE, "while" },
{ GDScriptTokenizer::TK_CF_BREAK, "break" }, { CScriptTokenizer::TK_CF_BREAK, "break" },
{ GDScriptTokenizer::TK_CF_CONTINUE, "continue" }, { CScriptTokenizer::TK_CF_CONTINUE, "continue" },
{ GDScriptTokenizer::TK_CF_RETURN, "return" }, { CScriptTokenizer::TK_CF_RETURN, "return" },
{ GDScriptTokenizer::TK_CF_MATCH, "match" }, { CScriptTokenizer::TK_CF_MATCH, "match" },
{ GDScriptTokenizer::TK_CF_PASS, "pass" }, { CScriptTokenizer::TK_CF_PASS, "pass" },
{ GDScriptTokenizer::TK_SELF, "self" }, { CScriptTokenizer::TK_SELF, "self" },
{ GDScriptTokenizer::TK_CONST_PI, "PI" }, { CScriptTokenizer::TK_CONST_PI, "PI" },
{ GDScriptTokenizer::TK_CONST_TAU, "TAU" }, { CScriptTokenizer::TK_CONST_TAU, "TAU" },
{ GDScriptTokenizer::TK_WILDCARD, "_" }, { CScriptTokenizer::TK_WILDCARD, "_" },
{ GDScriptTokenizer::TK_CONST_INF, "INF" }, { CScriptTokenizer::TK_CONST_INF, "INF" },
{ GDScriptTokenizer::TK_CONST_NAN, "NAN" }, { CScriptTokenizer::TK_CONST_NAN, "NAN" },
{ GDScriptTokenizer::TK_ERROR, nullptr } { CScriptTokenizer::TK_ERROR, nullptr }
}; };
const char *GDScriptTokenizer::get_token_name(Token p_token) { const char *CScriptTokenizer::get_token_name(Token p_token) {
ERR_FAIL_INDEX_V(p_token, TK_MAX, "<error>"); ERR_FAIL_INDEX_V(p_token, TK_MAX, "<error>");
return token_names[p_token]; return token_names[p_token];
} }
bool GDScriptTokenizer::is_token_literal(int p_offset, bool variable_safe) const { bool CScriptTokenizer::is_token_literal(int p_offset, bool variable_safe) const {
switch (get_token(p_offset)) { switch (get_token(p_offset)) {
// Can always be literal: // Can always be literal:
case TK_IDENTIFIER: case TK_IDENTIFIER:
@ -318,7 +318,7 @@ bool GDScriptTokenizer::is_token_literal(int p_offset, bool variable_safe) const
} }
} }
StringName GDScriptTokenizer::get_token_literal(int p_offset) const { StringName CScriptTokenizer::get_token_literal(int p_offset) const {
Token token = get_token(p_offset); Token token = get_token(p_offset);
switch (token) { switch (token) {
case TK_IDENTIFIER: case TK_IDENTIFIER:
@ -335,7 +335,7 @@ StringName GDScriptTokenizer::get_token_literal(int p_offset) const {
} }
} break; // Shouldn't get here, stuff happens } break; // Shouldn't get here, stuff happens
case TK_BUILT_IN_FUNC: case TK_BUILT_IN_FUNC:
return GDScriptFunctions::get_func_name(get_token_built_in_func(p_offset)); return CScriptFunctions::get_func_name(get_token_built_in_func(p_offset));
case TK_CONSTANT: { case TK_CONSTANT: {
const Variant value = get_token_constant(p_offset); const Variant value = get_token_constant(p_offset);
@ -381,7 +381,7 @@ static bool _is_bin(CharType c) {
return (c == '0' || c == '1'); return (c == '0' || c == '1');
} }
void GDScriptTokenizerText::_make_token(Token p_type) { void CScriptTokenizerText::_make_token(Token p_type) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = p_type; tk.type = p_type;
@ -390,7 +390,7 @@ void GDScriptTokenizerText::_make_token(Token p_type) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_identifier(const StringName &p_identifier) { void CScriptTokenizerText::_make_identifier(const StringName &p_identifier) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = TK_IDENTIFIER; tk.type = TK_IDENTIFIER;
@ -401,7 +401,7 @@ void GDScriptTokenizerText::_make_identifier(const StringName &p_identifier) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_built_in_func(GDScriptFunctions::Function p_func) { void CScriptTokenizerText::_make_built_in_func(CScriptFunctions::Function p_func) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = TK_BUILT_IN_FUNC; tk.type = TK_BUILT_IN_FUNC;
@ -411,7 +411,7 @@ void GDScriptTokenizerText::_make_built_in_func(GDScriptFunctions::Function p_fu
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_constant(const Variant &p_constant) { void CScriptTokenizerText::_make_constant(const Variant &p_constant) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = TK_CONSTANT; tk.type = TK_CONSTANT;
@ -422,7 +422,7 @@ void GDScriptTokenizerText::_make_constant(const Variant &p_constant) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_type(const Variant::Type &p_type) { void CScriptTokenizerText::_make_type(const Variant::Type &p_type) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = TK_BUILT_IN_TYPE; tk.type = TK_BUILT_IN_TYPE;
@ -433,7 +433,7 @@ void GDScriptTokenizerText::_make_type(const Variant::Type &p_type) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_error(const String &p_error) { void CScriptTokenizerText::_make_error(const String &p_error) {
error_flag = true; error_flag = true;
last_error = p_error; last_error = p_error;
@ -445,7 +445,7 @@ void GDScriptTokenizerText::_make_error(const String &p_error) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_make_newline(int p_indentation, int p_tabs) { void CScriptTokenizerText::_make_newline(int p_indentation, int p_tabs) {
TokenData &tk = tk_rb[tk_rb_pos]; TokenData &tk = tk_rb[tk_rb_pos];
tk.type = TK_NEWLINE; tk.type = TK_NEWLINE;
tk.constant = Vector2(p_indentation, p_tabs); tk.constant = Vector2(p_indentation, p_tabs);
@ -454,7 +454,7 @@ void GDScriptTokenizerText::_make_newline(int p_indentation, int p_tabs) {
tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE; tk_rb_pos = (tk_rb_pos + 1) % TK_RB_SIZE;
} }
void GDScriptTokenizerText::_advance() { void CScriptTokenizerText::_advance() {
if (error_flag) { if (error_flag) {
//parser broke //parser broke
_make_error(last_error); _make_error(last_error);
@ -1012,9 +1012,9 @@ void GDScriptTokenizerText::_advance() {
if (!found) { if (!found) {
//built in func? //built in func?
for (int j = 0; j < GDScriptFunctions::FUNC_MAX; j++) { for (int j = 0; j < CScriptFunctions::FUNC_MAX; j++) {
if (str == GDScriptFunctions::get_func_name(GDScriptFunctions::Function(j))) { if (str == CScriptFunctions::get_func_name(CScriptFunctions::Function(j))) {
_make_built_in_func(GDScriptFunctions::Function(j)); _make_built_in_func(CScriptFunctions::Function(j));
found = true; found = true;
break; break;
} }
@ -1060,7 +1060,7 @@ void GDScriptTokenizerText::_advance() {
} }
} }
void GDScriptTokenizerText::set_code(const String &p_code) { void CScriptTokenizerText::set_code(const String &p_code) {
code = p_code; code = p_code;
len = p_code.length(); len = p_code.length();
if (len) { if (len) {
@ -1082,7 +1082,7 @@ void GDScriptTokenizerText::set_code(const String &p_code) {
} }
} }
GDScriptTokenizerText::Token GDScriptTokenizerText::get_token(int p_offset) const { CScriptTokenizerText::Token CScriptTokenizerText::get_token(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, TK_ERROR); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, TK_ERROR);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, TK_ERROR); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, TK_ERROR);
@ -1090,7 +1090,7 @@ GDScriptTokenizerText::Token GDScriptTokenizerText::get_token(int p_offset) cons
return tk_rb[ofs].type; return tk_rb[ofs].type;
} }
int GDScriptTokenizerText::get_token_line(int p_offset) const { int CScriptTokenizerText::get_token_line(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
@ -1098,7 +1098,7 @@ int GDScriptTokenizerText::get_token_line(int p_offset) const {
return tk_rb[ofs].line; return tk_rb[ofs].line;
} }
int GDScriptTokenizerText::get_token_column(int p_offset) const { int CScriptTokenizerText::get_token_column(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, -1);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, -1);
@ -1106,7 +1106,7 @@ int GDScriptTokenizerText::get_token_column(int p_offset) const {
return tk_rb[ofs].col; return tk_rb[ofs].col;
} }
const Variant &GDScriptTokenizerText::get_token_constant(int p_offset) const { const Variant &CScriptTokenizerText::get_token_constant(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, tk_rb[0].constant);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, tk_rb[0].constant);
@ -1115,7 +1115,7 @@ const Variant &GDScriptTokenizerText::get_token_constant(int p_offset) const {
return tk_rb[ofs].constant; return tk_rb[ofs].constant;
} }
StringName GDScriptTokenizerText::get_token_identifier(int p_offset) const { StringName CScriptTokenizerText::get_token_identifier(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, StringName()); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, StringName());
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, StringName()); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, StringName());
@ -1124,16 +1124,16 @@ StringName GDScriptTokenizerText::get_token_identifier(int p_offset) const {
return tk_rb[ofs].identifier; return tk_rb[ofs].identifier;
} }
GDScriptFunctions::Function GDScriptTokenizerText::get_token_built_in_func(int p_offset) const { CScriptFunctions::Function CScriptTokenizerText::get_token_built_in_func(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, GDScriptFunctions::FUNC_MAX); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, CScriptFunctions::FUNC_MAX);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, GDScriptFunctions::FUNC_MAX); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, CScriptFunctions::FUNC_MAX);
int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE; int ofs = (TK_RB_SIZE + tk_rb_pos + p_offset - MAX_LOOKAHEAD - 1) % TK_RB_SIZE;
ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_FUNC, GDScriptFunctions::FUNC_MAX); ERR_FAIL_COND_V(tk_rb[ofs].type != TK_BUILT_IN_FUNC, CScriptFunctions::FUNC_MAX);
return tk_rb[ofs].func; return tk_rb[ofs].func;
} }
Variant::Type GDScriptTokenizerText::get_token_type(int p_offset) const { Variant::Type CScriptTokenizerText::get_token_type(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, Variant::NIL); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, Variant::NIL);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, Variant::NIL); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, Variant::NIL);
@ -1142,7 +1142,7 @@ Variant::Type GDScriptTokenizerText::get_token_type(int p_offset) const {
return tk_rb[ofs].vtype; return tk_rb[ofs].vtype;
} }
int GDScriptTokenizerText::get_token_line_indent(int p_offset) const { int CScriptTokenizerText::get_token_line_indent(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0);
@ -1151,7 +1151,7 @@ int GDScriptTokenizerText::get_token_line_indent(int p_offset) const {
return tk_rb[ofs].constant.operator Vector2().x; return tk_rb[ofs].constant.operator Vector2().x;
} }
int GDScriptTokenizerText::get_token_line_tab_indent(int p_offset) const { int CScriptTokenizerText::get_token_line_tab_indent(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, 0);
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, 0);
@ -1160,7 +1160,7 @@ int GDScriptTokenizerText::get_token_line_tab_indent(int p_offset) const {
return tk_rb[ofs].constant.operator Vector2().y; return tk_rb[ofs].constant.operator Vector2().y;
} }
String GDScriptTokenizerText::get_token_error(int p_offset) const { String CScriptTokenizerText::get_token_error(int p_offset) const {
ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, String()); ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, String());
ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, String()); ERR_FAIL_COND_V(p_offset >= MAX_LOOKAHEAD, String());
@ -1169,7 +1169,7 @@ String GDScriptTokenizerText::get_token_error(int p_offset) const {
return tk_rb[ofs].constant; return tk_rb[ofs].constant;
} }
void GDScriptTokenizerText::advance(int p_amount) { void CScriptTokenizerText::advance(int p_amount) {
ERR_FAIL_COND(p_amount <= 0); ERR_FAIL_COND(p_amount <= 0);
for (int i = 0; i < p_amount; i++) { for (int i = 0; i < p_amount; i++) {
_advance(); _advance();
@ -1180,7 +1180,7 @@ void GDScriptTokenizerText::advance(int p_amount) {
#define BYTECODE_VERSION 13 #define BYTECODE_VERSION 13
Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer) { Error CScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer) {
const uint8_t *buf = p_buffer.ptr(); const uint8_t *buf = p_buffer.ptr();
int total_len = p_buffer.size(); int total_len = p_buffer.size();
ERR_FAIL_COND_V(p_buffer.size() < 24 || p_buffer[0] != 'G' || p_buffer[1] != 'D' || p_buffer[2] != 'S' || p_buffer[3] != 'C', ERR_INVALID_DATA); ERR_FAIL_COND_V(p_buffer.size() < 24 || p_buffer[0] != 'G' || p_buffer[1] != 'D' || p_buffer[2] != 'S' || p_buffer[3] != 'C', ERR_INVALID_DATA);
@ -1263,7 +1263,7 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
return OK; return OK;
} }
Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code) { Vector<uint8_t> CScriptTokenizerBuffer::parse_code_string(const String &p_code) {
Vector<uint8_t> buf; Vector<uint8_t> buf;
Map<StringName, int> identifier_map; Map<StringName, int> identifier_map;
@ -1271,7 +1271,7 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
Map<uint32_t, int> line_map; Map<uint32_t, int> line_map;
Vector<uint32_t> token_array; Vector<uint32_t> token_array;
GDScriptTokenizerText tt; CScriptTokenizerText tt;
tt.set_code(p_code); tt.set_code(p_code);
int line = -1; int line = -1;
@ -1413,17 +1413,17 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
return buf; return buf;
} }
GDScriptTokenizerBuffer::Token GDScriptTokenizerBuffer::get_token(int p_offset) const { CScriptTokenizerBuffer::Token CScriptTokenizerBuffer::get_token(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
if (offset < 0 || offset >= tokens.size()) { if (offset < 0 || offset >= tokens.size()) {
return TK_EOF; return TK_EOF;
} }
return GDScriptTokenizerBuffer::Token(tokens[offset] & TOKEN_MASK); return CScriptTokenizerBuffer::Token(tokens[offset] & TOKEN_MASK);
} }
StringName GDScriptTokenizerBuffer::get_token_identifier(int p_offset) const { StringName CScriptTokenizerBuffer::get_token_identifier(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
ERR_FAIL_INDEX_V(offset, tokens.size(), StringName()); ERR_FAIL_INDEX_V(offset, tokens.size(), StringName());
@ -1433,20 +1433,20 @@ StringName GDScriptTokenizerBuffer::get_token_identifier(int p_offset) const {
return identifiers[identifier]; return identifiers[identifier];
} }
GDScriptFunctions::Function GDScriptTokenizerBuffer::get_token_built_in_func(int p_offset) const { CScriptFunctions::Function CScriptTokenizerBuffer::get_token_built_in_func(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
ERR_FAIL_INDEX_V(offset, tokens.size(), GDScriptFunctions::FUNC_MAX); ERR_FAIL_INDEX_V(offset, tokens.size(), CScriptFunctions::FUNC_MAX);
return GDScriptFunctions::Function(tokens[offset] >> TOKEN_BITS); return CScriptFunctions::Function(tokens[offset] >> TOKEN_BITS);
} }
Variant::Type GDScriptTokenizerBuffer::get_token_type(int p_offset) const { Variant::Type CScriptTokenizerBuffer::get_token_type(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
ERR_FAIL_INDEX_V(offset, tokens.size(), Variant::NIL); ERR_FAIL_INDEX_V(offset, tokens.size(), Variant::NIL);
return Variant::Type(tokens[offset] >> TOKEN_BITS); return Variant::Type(tokens[offset] >> TOKEN_BITS);
} }
int GDScriptTokenizerBuffer::get_token_line(int p_offset) const { int CScriptTokenizerBuffer::get_token_line(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
int pos = lines.find_nearest(offset); int pos = lines.find_nearest(offset);
@ -1460,7 +1460,7 @@ int GDScriptTokenizerBuffer::get_token_line(int p_offset) const {
uint32_t l = lines.getv(pos); uint32_t l = lines.getv(pos);
return l & TOKEN_LINE_MASK; return l & TOKEN_LINE_MASK;
} }
int GDScriptTokenizerBuffer::get_token_column(int p_offset) const { int CScriptTokenizerBuffer::get_token_column(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
int pos = lines.find_nearest(offset); int pos = lines.find_nearest(offset);
if (pos < 0) { if (pos < 0) {
@ -1473,26 +1473,26 @@ int GDScriptTokenizerBuffer::get_token_column(int p_offset) const {
uint32_t l = lines.getv(pos); uint32_t l = lines.getv(pos);
return l >> TOKEN_LINE_BITS; return l >> TOKEN_LINE_BITS;
} }
int GDScriptTokenizerBuffer::get_token_line_indent(int p_offset) const { int CScriptTokenizerBuffer::get_token_line_indent(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
ERR_FAIL_INDEX_V(offset, tokens.size(), 0); ERR_FAIL_INDEX_V(offset, tokens.size(), 0);
return tokens[offset] >> TOKEN_BITS; return tokens[offset] >> TOKEN_BITS;
} }
const Variant &GDScriptTokenizerBuffer::get_token_constant(int p_offset) const { const Variant &CScriptTokenizerBuffer::get_token_constant(int p_offset) const {
int offset = token + p_offset; int offset = token + p_offset;
ERR_FAIL_INDEX_V(offset, tokens.size(), nil); ERR_FAIL_INDEX_V(offset, tokens.size(), nil);
uint32_t constant = tokens[offset] >> TOKEN_BITS; uint32_t constant = tokens[offset] >> TOKEN_BITS;
ERR_FAIL_UNSIGNED_INDEX_V(constant, (uint32_t)constants.size(), nil); ERR_FAIL_UNSIGNED_INDEX_V(constant, (uint32_t)constants.size(), nil);
return constants[constant]; return constants[constant];
} }
String GDScriptTokenizerBuffer::get_token_error(int p_offset) const { String CScriptTokenizerBuffer::get_token_error(int p_offset) const {
ERR_FAIL_V(String()); ERR_FAIL_V(String());
} }
void GDScriptTokenizerBuffer::advance(int p_amount) { void CScriptTokenizerBuffer::advance(int p_amount) {
ERR_FAIL_INDEX(p_amount + token, tokens.size()); ERR_FAIL_INDEX(p_amount + token, tokens.size());
token += p_amount; token += p_amount;
} }
GDScriptTokenizerBuffer::GDScriptTokenizerBuffer() { CScriptTokenizerBuffer::CScriptTokenizerBuffer() {
token = 0; token = 0;
} }

22
modules/cscript/cscript_tokenizer.h
View File

@ -37,7 +37,7 @@
#include "core/vmap.h" #include "core/vmap.h"
#include "cscript_functions.h" #include "cscript_functions.h"
class GDScriptTokenizer { class CScriptTokenizer {
public: public:
enum Token { enum Token {
@ -162,7 +162,7 @@ public:
virtual const Variant &get_token_constant(int p_offset = 0) const = 0; virtual const Variant &get_token_constant(int p_offset = 0) const = 0;
virtual Token get_token(int p_offset = 0) const = 0; virtual Token get_token(int p_offset = 0) const = 0;
virtual StringName get_token_identifier(int p_offset = 0) const = 0; virtual StringName get_token_identifier(int p_offset = 0) const = 0;
virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const = 0; virtual CScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const = 0;
virtual Variant::Type get_token_type(int p_offset = 0) const = 0; virtual Variant::Type get_token_type(int p_offset = 0) const = 0;
virtual int get_token_line(int p_offset = 0) const = 0; virtual int get_token_line(int p_offset = 0) const = 0;
virtual int get_token_column(int p_offset = 0) const = 0; virtual int get_token_column(int p_offset = 0) const = 0;
@ -176,10 +176,10 @@ public:
virtual bool is_ignoring_warnings() const = 0; virtual bool is_ignoring_warnings() const = 0;
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
virtual ~GDScriptTokenizer(){}; virtual ~CScriptTokenizer(){};
}; };
class GDScriptTokenizerText : public GDScriptTokenizer { class CScriptTokenizerText : public CScriptTokenizer {
enum { enum {
MAX_LOOKAHEAD = 4, MAX_LOOKAHEAD = 4,
TK_RB_SIZE = MAX_LOOKAHEAD * 2 + 1 TK_RB_SIZE = MAX_LOOKAHEAD * 2 + 1
@ -192,7 +192,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
Variant constant; //for constant types Variant constant; //for constant types
union { union {
Variant::Type vtype; //for type types Variant::Type vtype; //for type types
GDScriptFunctions::Function func; //function for built in functions CScriptFunctions::Function func; //function for built in functions
int warning_code; //for warning skip int warning_code; //for warning skip
}; };
int line, col; int line, col;
@ -206,7 +206,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
void _make_token(Token p_type); void _make_token(Token p_type);
void _make_newline(int p_indentation = 0, int p_tabs = 0); void _make_newline(int p_indentation = 0, int p_tabs = 0);
void _make_identifier(const StringName &p_identifier); void _make_identifier(const StringName &p_identifier);
void _make_built_in_func(GDScriptFunctions::Function p_func); void _make_built_in_func(CScriptFunctions::Function p_func);
void _make_constant(const Variant &p_constant); void _make_constant(const Variant &p_constant);
void _make_type(const Variant::Type &p_type); void _make_type(const Variant::Type &p_type);
void _make_error(const String &p_error); void _make_error(const String &p_error);
@ -234,7 +234,7 @@ public:
void set_code(const String &p_code); void set_code(const String &p_code);
virtual Token get_token(int p_offset = 0) const; virtual Token get_token(int p_offset = 0) const;
virtual StringName get_token_identifier(int p_offset = 0) const; virtual StringName get_token_identifier(int p_offset = 0) const;
virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const; virtual CScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const;
virtual Variant::Type get_token_type(int p_offset = 0) const; virtual Variant::Type get_token_type(int p_offset = 0) const;
virtual int get_token_line(int p_offset = 0) const; virtual int get_token_line(int p_offset = 0) const;
virtual int get_token_column(int p_offset = 0) const; virtual int get_token_column(int p_offset = 0) const;
@ -256,7 +256,7 @@ public:
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
}; };
class GDScriptTokenizerBuffer : public GDScriptTokenizer { class CScriptTokenizerBuffer : public CScriptTokenizer {
enum { enum {
TOKEN_BYTE_MASK = 0x80, TOKEN_BYTE_MASK = 0x80,
@ -278,7 +278,7 @@ public:
static Vector<uint8_t> parse_code_string(const String &p_code); static Vector<uint8_t> parse_code_string(const String &p_code);
virtual Token get_token(int p_offset = 0) const; virtual Token get_token(int p_offset = 0) const;
virtual StringName get_token_identifier(int p_offset = 0) const; virtual StringName get_token_identifier(int p_offset = 0) const;
virtual GDScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const; virtual CScriptFunctions::Function get_token_built_in_func(int p_offset = 0) const;
virtual Variant::Type get_token_type(int p_offset = 0) const; virtual Variant::Type get_token_type(int p_offset = 0) const;
virtual int get_token_line(int p_offset = 0) const; virtual int get_token_line(int p_offset = 0) const;
virtual int get_token_column(int p_offset = 0) const; virtual int get_token_column(int p_offset = 0) const;
@ -300,7 +300,7 @@ public:
return true; return true;
} }
#endif // DEBUG_ENABLED #endif // DEBUG_ENABLED
GDScriptTokenizerBuffer(); CScriptTokenizerBuffer();
}; };
#endif // GDSCRIPT_TOKENIZER_H #endif // CSCRIPT_TOKENIZER_H

21
modules/cscript/doc_classes/@CScript.xml
View File

@ -1,13 +1,12 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8"?>
<class name="@GDScript" version="3.5"> <class name="@CScript" version="3.5">
<brief_description> <brief_description>
Built-in GDScript functions. Built-in CScript functions.
</brief_description> </brief_description>
<description> <description>
List of core built-in GDScript functions. Math functions and other utilities. Everything else is provided by objects. (Keywords: builtin, built in, global functions.) List of core built-in CScript functions. Math functions and other utilities. Everything else is provided by objects. (Keywords: builtin, built in, global functions.)
</description> </description>
<tutorials> <tutorials></tutorials>
</tutorials>
<methods> <methods>
<method name="Color8"> <method name="Color8">
<return type="Color" /> <return type="Color" />
@ -511,7 +510,7 @@
<argument index="2" name="weight" type="float" /> <argument index="2" name="weight" type="float" />
<description> <description>
Linearly interpolates between two angles (in radians) by a normalized value. Linearly interpolates between two angles (in radians) by a normalized value.
Similar to [method lerp], but interpolates correctly when the angles wrap around [constant @GDScript.TAU]. To perform eased interpolation with [method lerp_angle], combine it with [method ease] or [method smoothstep]. Similar to [method lerp], but interpolates correctly when the angles wrap around [constant @CScript.TAU]. To perform eased interpolation with [method lerp_angle], combine it with [method ease] or [method smoothstep].
[codeblock] [codeblock]
extends Sprite extends Sprite
var elapsed = 0.0 var elapsed = 0.0
@ -1185,12 +1184,12 @@
</description> </description>
</method> </method>
<method name="yield"> <method name="yield">
<return type="GDScriptFunctionState" /> <return type="CScriptFunctionState" />
<argument index="0" name="object" type="Object" default="null" /> <argument index="0" name="object" type="Object" default="null" />
<argument index="1" name="signal" type="String" default="&quot;&quot;" /> <argument index="1" name="signal" type="String" default="&quot;&quot;" />
<description> <description>
Stops the function execution and returns the current suspended state to the calling function. Stops the function execution and returns the current suspended state to the calling function.
From the caller, call [method GDScriptFunctionState.resume] on the state to resume execution. This invalidates the state. Within the resumed function, [code]yield()[/code] returns whatever was passed to the [code]resume()[/code] function call. From the caller, call [method CScriptFunctionState.resume] on the state to resume execution. This invalidates the state. Within the resumed function, [code]yield()[/code] returns whatever was passed to the [code]resume()[/code] function call.
If passed an object and a signal, the execution is resumed when the object emits the given signal. In this case, [code]yield()[/code] returns the argument passed to [code]emit_signal()[/code] if the signal takes only one argument, or an array containing all the arguments passed to [code]emit_signal()[/code] if the signal takes multiple arguments. If passed an object and a signal, the execution is resumed when the object emits the given signal. In this case, [code]yield()[/code] returns the argument passed to [code]emit_signal()[/code] if the signal takes only one argument, or an array containing all the arguments passed to [code]emit_signal()[/code] if the signal takes multiple arguments.
You can also use [code]yield[/code] to wait for a function to finish: You can also use [code]yield[/code] to wait for a function to finish:
[codeblock] [codeblock]
@ -1199,7 +1198,7 @@
print('Ready') print('Ready')
func countdown(): func countdown():
yield(get_tree(), "idle_frame") # returns a GDScriptFunctionState object to _ready() yield(get_tree(), "idle_frame") # returns a CScriptFunctionState object to _ready()
print(3) print(3)
yield(get_tree().create_timer(1.0), "timeout") yield(get_tree().create_timer(1.0), "timeout")
print(2) print(2)
@ -1214,7 +1213,7 @@
# Ready # Ready
[/codeblock] [/codeblock]
When yielding on a function, the [code]completed[/code] signal will be emitted automatically when the function returns. It can, therefore, be used as the [code]signal[/code] parameter of the [code]yield[/code] method to resume. When yielding on a function, the [code]completed[/code] signal will be emitted automatically when the function returns. It can, therefore, be used as the [code]signal[/code] parameter of the [code]yield[/code] method to resume.
In order to yield on a function, the resulting function should also return a [code]GDScriptFunctionState[/code]. Notice [code]yield(get_tree(), "idle_frame")[/code] from the above example. In order to yield on a function, the resulting function should also return a [code]CScriptFunctionState[/code]. Notice [code]yield(get_tree(), "idle_frame")[/code] from the above example.
</description> </description>
</method> </method>
</methods> </methods>

11
modules/cscript/doc_classes/CScript.xml
View File

@ -1,10 +1,10 @@
<?xml version="1.0" encoding="UTF-8" ?> <?xml version="1.0" encoding="UTF-8"?>
<class name="GDScript" inherits="Script" version="3.5"> <class name="CScript" inherits="Script" version="3.5">
<brief_description> <brief_description>
A script implemented in the GDScript programming language. A script implemented in the CScript programming language.
</brief_description> </brief_description>
<description> <description>
A script implemented in the GDScript programming language. The script extends the functionality of all objects that instance it. A script implemented in the CScript programming language. The script extends the functionality of all objects that instance it.
[method new] creates a new instance of the script. [method Object.set_script] extends an existing object, if that object's class matches one of the script's base classes. [method new] creates a new instance of the script. [method Object.set_script] extends an existing object, if that object's class matches one of the script's base classes.
</description> </description>
<tutorials> <tutorials>
@ -30,6 +30,5 @@
</description> </description>
</method> </method>
</methods> </methods>
<constants> <constants></constants>
</constants>
</class> </class>

24
modules/cscript/editor/cscript_highlighter.cpp
View File

@ -28,8 +28,8 @@
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#include "gdscript_highlighter.h" #include "cscript_highlighter.h"
#include "../gdscript_tokenizer.h" #include "../cscript_tokenizer.h"
#include "editor/editor_settings.h" #include "editor/editor_settings.h"
#include "scene/gui/text_edit.h" #include "scene/gui/text_edit.h"
@ -57,7 +57,7 @@ static bool _is_bin_symbol(CharType c) {
return (c == '0' || c == '1'); return (c == '0' || c == '1');
} }
Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_highlighting(int p_line) { Map<int, TextEdit::HighlighterInfo> CScriptSyntaxHighlighter::_get_line_syntax_highlighting(int p_line) {
Map<int, TextEdit::HighlighterInfo> color_map; Map<int, TextEdit::HighlighterInfo> color_map;
Type next_type = NONE; Type next_type = NONE;
@ -219,7 +219,7 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
if (str[k] == '(') { if (str[k] == '(') {
in_function_name = true; in_function_name = true;
} else if (previous_text == GDScriptTokenizer::get_token_name(GDScriptTokenizer::TK_PR_VAR)) { } else if (previous_text == CScriptTokenizer::get_token_name(CScriptTokenizer::TK_PR_VAR)) {
in_variable_declaration = true; in_variable_declaration = true;
} }
} }
@ -291,7 +291,7 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
} else if (in_function_name) { } else if (in_function_name) {
next_type = FUNCTION; next_type = FUNCTION;
if (previous_text == GDScriptTokenizer::get_token_name(GDScriptTokenizer::TK_PR_FUNCTION)) { if (previous_text == CScriptTokenizer::get_token_name(CScriptTokenizer::TK_PR_FUNCTION)) {
color = function_definition_color; color = function_definition_color;
} else { } else {
color = function_color; color = function_color;
@ -344,17 +344,17 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
return color_map; return color_map;
} }
String GDScriptSyntaxHighlighter::get_name() const { String CScriptSyntaxHighlighter::get_name() const {
return "GDScript"; return "CScript";
} }
List<String> GDScriptSyntaxHighlighter::get_supported_languages() { List<String> CScriptSyntaxHighlighter::get_supported_languages() {
List<String> languages; List<String> languages;
languages.push_back("GDScript"); languages.push_back("CScript");
return languages; return languages;
} }
void GDScriptSyntaxHighlighter::_update_cache() { void CScriptSyntaxHighlighter::_update_cache() {
font_color = text_editor->get_color("font_color"); font_color = text_editor->get_color("font_color");
symbol_color = text_editor->get_color("symbol_color"); symbol_color = text_editor->get_color("symbol_color");
function_color = text_editor->get_color("function_color"); function_color = text_editor->get_color("function_color");
@ -390,6 +390,6 @@ void GDScriptSyntaxHighlighter::_update_cache() {
type_color = EDITOR_GET("text_editor/highlighting/base_type_color"); type_color = EDITOR_GET("text_editor/highlighting/base_type_color");
} }
SyntaxHighlighter *GDScriptSyntaxHighlighter::create() { SyntaxHighlighter *CScriptSyntaxHighlighter::create() {
return memnew(GDScriptSyntaxHighlighter); return memnew(CScriptSyntaxHighlighter);
} }

4
modules/cscript/editor/cscript_highlighter.h
View File

@ -32,7 +32,7 @@
#include "scene/gui/text_edit.h" #include "scene/gui/text_edit.h"
class GDScriptSyntaxHighlighter : public SyntaxHighlighter { class CScriptSyntaxHighlighter : public SyntaxHighlighter {
private: private:
enum Type { enum Type {
NONE, NONE,
@ -68,4 +68,4 @@ public:
virtual List<String> get_supported_languages(); virtual List<String> get_supported_languages();
}; };
#endif // GDSCRIPT_HIGHLIGHTER_H #endif // CSCRIPT_HIGHLIGHTER_H

52
modules/cscript/register_types.cpp
View File

@ -37,19 +37,19 @@
#include "cscript.h" #include "cscript.h"
#include "cscript_tokenizer.h" #include "cscript_tokenizer.h"
GDScriptLanguage *script_language_gd = nullptr; CScriptLanguage *script_language_cscript = nullptr;
Ref<ResourceFormatLoaderGDScript> resource_loader_gd; Ref<ResourceFormatLoaderCScript> resource_loader_cscript;
Ref<ResourceFormatSaverGDScript> resource_saver_gd; Ref<ResourceFormatSaverCScript> resource_saver_cscript;
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
#include "editor/cscript_highlighter.h"
#include "editor/editor_export.h" #include "editor/editor_export.h"
#include "editor/editor_node.h" #include "editor/editor_node.h"
#include "editor/editor_settings.h" #include "editor/editor_settings.h"
#include "editor/gdscript_highlighter.h"
class EditorExportGDScript : public EditorExportPlugin { class EditorExportCScript : public EditorExportPlugin {
GDCLASS(EditorExportGDScript, EditorExportPlugin); GDCLASS(EditorExportCScript, EditorExportPlugin);
public: public:
virtual void _export_file(const String &p_path, const String &p_type, const Set<String> &p_features) { virtual void _export_file(const String &p_path, const String &p_type, const Set<String> &p_features) {
@ -74,7 +74,7 @@ public:
String txt; String txt;
txt.parse_utf8((const char *)file.ptr(), file.size()); txt.parse_utf8((const char *)file.ptr(), file.size());
file = GDScriptTokenizerBuffer::parse_code_string(txt); file = CScriptTokenizerBuffer::parse_code_string(txt);
if (!file.empty()) { if (!file.empty()) {
if (script_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) { if (script_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) {
@ -129,42 +129,42 @@ public:
}; };
static void _editor_init() { static void _editor_init() {
Ref<EditorExportGDScript> gd_export; Ref<EditorExportCScript> gd_export;
gd_export.instance(); gd_export.instance();
EditorExport::get_singleton()->add_export_plugin(gd_export); EditorExport::get_singleton()->add_export_plugin(gd_export);
} }
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
void register_gdscript_types() { void register_cscript_types() {
ClassDB::register_class<GDScript>(); ClassDB::register_class<CScript>();
ClassDB::register_virtual_class<GDScriptFunctionState>(); ClassDB::register_virtual_class<CScriptFunctionState>();
script_language_gd = memnew(GDScriptLanguage); script_language_cscript = memnew(CScriptLanguage);
ScriptServer::register_language(script_language_gd); ScriptServer::register_language(script_language_cscript);
resource_loader_gd.instance(); resource_loader_cscript.instance();
ResourceLoader::add_resource_format_loader(resource_loader_gd); ResourceLoader::add_resource_format_loader(resource_loader_cscript);
resource_saver_gd.instance(); resource_saver_cscript.instance();
ResourceSaver::add_resource_format_saver(resource_saver_gd); ResourceSaver::add_resource_format_saver(resource_saver_cscript);
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
ScriptEditor::register_create_syntax_highlighter_function(GDScriptSyntaxHighlighter::create); ScriptEditor::register_create_syntax_highlighter_function(CScriptSyntaxHighlighter::create);
EditorNode::add_init_callback(_editor_init); EditorNode::add_init_callback(_editor_init);
#endif // TOOLS_ENABLED #endif // TOOLS_ENABLED
} }
void unregister_gdscript_types() { void unregister_cscript_types() {
ScriptServer::unregister_language(script_language_gd); ScriptServer::unregister_language(script_language_cscript);
if (script_language_gd) { if (script_language_cscript) {
memdelete(script_language_gd); memdelete(script_language_cscript);
} }
ResourceLoader::remove_resource_format_loader(resource_loader_gd); ResourceLoader::remove_resource_format_loader(resource_loader_cscript);
resource_loader_gd.unref(); resource_loader_cscript.unref();
ResourceSaver::remove_resource_format_saver(resource_saver_gd); ResourceSaver::remove_resource_format_saver(resource_saver_cscript);
resource_saver_gd.unref(); resource_saver_cscript.unref();
} }

2
modules/cscript/register_types.h
View File

@ -33,4 +33,4 @@
void register_cscript_types(); void register_cscript_types();
void unregister_cscript_types(); void unregister_cscript_types();
#endif // GDSCRIPT_REGISTER_TYPES_H #endif // CSCRIPT_REGISTER_TYPES_H