diff --git a/modules/cscript/cscript.cpp b/modules/cscript/cscript.cpp
index db110202a..664774940 100644
--- a/modules/cscript/cscript.cpp
+++ b/modules/cscript/cscript.cpp
@@ -41,11 +41,11 @@
 
 ///////////////////////////
 
-GDScriptNativeClass::GDScriptNativeClass(const StringName &p_name) {
+CScriptNativeClass::CScriptNativeClass(const StringName &p_name) {
 	name = p_name;
 }
 
-bool GDScriptNativeClass::_get(const StringName &p_name, Variant &r_ret) const {
+bool CScriptNativeClass::_get(const StringName &p_name, Variant &r_ret) const {
 	bool ok;
 	int v = ClassDB::get_integer_constant(name, p_name, &ok);
 
@@ -57,11 +57,11 @@ bool GDScriptNativeClass::_get(const StringName &p_name, Variant &r_ret) const {
 	}
 }
 
-void GDScriptNativeClass::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("new"), &GDScriptNativeClass::_new);
+void CScriptNativeClass::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("new"), &CScriptNativeClass::_new);
 }
 
-Variant GDScriptNativeClass::_new() {
+Variant CScriptNativeClass::_new() {
 	Object *o = instance();
 	ERR_FAIL_COND_V_MSG(!o, Variant(), "Class type: '" + String(name) + "' is not instantiable.");
 
@@ -73,28 +73,28 @@ Variant GDScriptNativeClass::_new() {
 	}
 }
 
-Object *GDScriptNativeClass::instance() {
+Object *CScriptNativeClass::instance() {
 	return ClassDB::instance(name);
 }
 
-void GDScript::_clear_pending_func_states() {
-	GDScriptLanguage::get_singleton()->lock.lock();
-	while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
+void CScript::_clear_pending_func_states() {
+	CScriptLanguage::get_singleton()->lock.lock();
+	while (SelfList<CScriptFunctionState> *E = pending_func_states.first()) {
 		// Order matters since clearing the stack may already cause
-		// the GDSCriptFunctionState to be destroyed and thus removed from the list.
+		// the CSCriptFunctionState to be destroyed and thus removed from the list.
 		pending_func_states.remove(E);
 		E->self()->_clear_stack();
 	}
-	GDScriptLanguage::get_singleton()->lock.unlock();
+	CScriptLanguage::get_singleton()->lock.unlock();
 }
 
-GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error) {
+CScriptInstance *CScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error) {
 	/* STEP 1, CREATE */
 
-	GDScriptInstance *instance = memnew(GDScriptInstance);
+	CScriptInstance *instance = memnew(CScriptInstance);
 	instance->base_ref = p_isref;
 	instance->members.resize(member_indices.size());
-	instance->script = Ref<GDScript>(this);
+	instance->script = Ref<CScript>(this);
 	instance->owner = p_owner;
 #ifdef DEBUG_ENABLED
 	//needed for hot reloading
@@ -106,21 +106,21 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 
 	/* STEP 2, INITIALIZE AND CONSTRUCT */
 
-	GDScriptLanguage::singleton->lock.lock();
+	CScriptLanguage::singleton->lock.lock();
 	instances.insert(instance->owner);
-	GDScriptLanguage::singleton->lock.unlock();
+	CScriptLanguage::singleton->lock.unlock();
 
 	initializer->call(instance, p_args, p_argcount, r_error);
 
 	if (r_error.error != Variant::CallError::CALL_OK) {
-		instance->script = Ref<GDScript>();
+		instance->script = Ref<CScript>();
 		instance->owner->set_script_instance(nullptr);
 #ifndef NO_THREADS
-		GDScriptLanguage::singleton->lock.lock();
+		CScriptLanguage::singleton->lock.lock();
 #endif
 		instances.erase(p_owner);
 #ifndef NO_THREADS
-		GDScriptLanguage::singleton->lock.unlock();
+		CScriptLanguage::singleton->lock.unlock();
 #endif
 
 		ERR_FAIL_COND_V(r_error.error != Variant::CallError::CALL_OK, nullptr); //error constructing
@@ -130,7 +130,7 @@ GDScriptInstance *GDScript::_create_instance(const Variant **p_args, int p_argco
 	return instance;
 }
 
-Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+Variant CScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 	/* STEP 1, CREATE */
 
 	if (!valid) {
@@ -142,7 +142,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallErro
 	REF ref;
 	Object *owner = nullptr;
 
-	GDScript *_baseptr = this;
+	CScript *_baseptr = this;
 	while (_baseptr->_base) {
 		_baseptr = _baseptr->_base;
 	}
@@ -160,7 +160,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallErro
 		ref = REF(r);
 	}
 
-	GDScriptInstance *instance = _create_instance(p_args, p_argcount, owner, r != nullptr, r_error);
+	CScriptInstance *instance = _create_instance(p_args, p_argcount, owner, r != nullptr, r_error);
 	if (!instance) {
 		if (ref.is_null()) {
 			memdelete(owner); //no owner, sorry
@@ -175,7 +175,7 @@ Variant GDScript::_new(const Variant **p_args, int p_argcount, Variant::CallErro
 	}
 }
 
-bool GDScript::can_instance() const {
+bool CScript::can_instance() const {
 #ifdef TOOLS_ENABLED
 	return valid && (tool || ScriptServer::is_scripting_enabled());
 #else
@@ -183,15 +183,15 @@ bool GDScript::can_instance() const {
 #endif
 }
 
-Ref<Script> GDScript::get_base_script() const {
+Ref<Script> CScript::get_base_script() const {
 	if (_base) {
-		return Ref<GDScript>(_base);
+		return Ref<CScript>(_base);
 	} else {
 		return Ref<Script>();
 	}
 }
 
-StringName GDScript::get_instance_base_type() const {
+StringName CScript::get_instance_base_type() const {
 	if (native.is_valid()) {
 		return native->get_name();
 	}
@@ -201,24 +201,24 @@ StringName GDScript::get_instance_base_type() const {
 	return StringName();
 }
 
-struct _GDScriptMemberSort {
+struct _CScriptMemberSort {
 	int index;
 	StringName name;
-	_FORCE_INLINE_ bool operator<(const _GDScriptMemberSort &p_member) const { return index < p_member.index; }
+	_FORCE_INLINE_ bool operator<(const _CScriptMemberSort &p_member) const { return index < p_member.index; }
 };
 
 #ifdef TOOLS_ENABLED
 
-void GDScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
+void CScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
 	placeholders.erase(p_placeholder);
 }
 #endif
 
-void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
-	const GDScript *current = this;
+void CScript::get_script_method_list(List<MethodInfo> *p_list) const {
+	const CScript *current = this;
 	while (current) {
-		for (const Map<StringName, GDScriptFunction *>::Element *E = current->member_functions.front(); E; E = E->next()) {
-			GDScriptFunction *func = E->get();
+		for (const Map<StringName, CScriptFunction *>::Element *E = current->member_functions.front(); E; E = E->next()) {
+			CScriptFunction *func = E->get();
 			MethodInfo mi;
 			mi.name = E->key();
 			for (int i = 0; i < func->get_argument_count(); i++) {
@@ -233,14 +233,14 @@ void GDScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
-	const GDScript *sptr = this;
+void CScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+	const CScript *sptr = this;
 	List<PropertyInfo> props;
 
 	while (sptr) {
-		Vector<_GDScriptMemberSort> msort;
+		Vector<_CScriptMemberSort> msort;
 		for (Map<StringName, PropertyInfo>::Element *E = sptr->member_info.front(); E; E = E->next()) {
-			_GDScriptMemberSort ms;
+			_CScriptMemberSort ms;
 			ERR_CONTINUE(!sptr->member_indices.has(E->key()));
 			ms.index = sptr->member_indices[E->key()].index;
 			ms.name = E->key();
@@ -261,17 +261,17 @@ void GDScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	}
 }
 
-bool GDScript::has_method(const StringName &p_method) const {
+bool CScript::has_method(const StringName &p_method) const {
 	return member_functions.has(p_method);
 }
 
-MethodInfo GDScript::get_method_info(const StringName &p_method) const {
-	const Map<StringName, GDScriptFunction *>::Element *E = member_functions.find(p_method);
+MethodInfo CScript::get_method_info(const StringName &p_method) const {
+	const Map<StringName, CScriptFunction *>::Element *E = member_functions.find(p_method);
 	if (!E) {
 		return MethodInfo();
 	}
 
-	GDScriptFunction *func = E->get();
+	CScriptFunction *func = E->get();
 	MethodInfo mi;
 	mi.name = E->key();
 	for (int i = 0; i < func->get_argument_count(); i++) {
@@ -282,7 +282,7 @@ MethodInfo GDScript::get_method_info(const StringName &p_method) const {
 	return mi;
 }
 
-bool GDScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
+bool CScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
 #ifdef TOOLS_ENABLED
 
 	const Map<StringName, Variant>::Element *E = member_default_values_cache.find(p_property);
@@ -298,8 +298,8 @@ bool GDScript::get_property_default_value(const StringName &p_property, Variant
 	return false;
 }
 
-ScriptInstance *GDScript::instance_create(Object *p_this) {
-	GDScript *top = this;
+ScriptInstance *CScript::instance_create(Object *p_this) {
+	CScript *top = this;
 	while (top->_base) {
 		top = top->_base;
 	}
@@ -307,7 +307,7 @@ ScriptInstance *GDScript::instance_create(Object *p_this) {
 	if (top->native.is_valid()) {
 		if (!ClassDB::is_parent_class(p_this->get_class_name(), top->native->get_name())) {
 			if (ScriptDebugger::get_singleton()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), 1, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'");
+				CScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), 1, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type: '" + p_this->get_class() + "'");
 			}
 			ERR_FAIL_V_MSG(nullptr, "Script inherits from native type '" + String(top->native->get_name()) + "', so it can't be instanced in object of type '" + p_this->get_class() + "'" + ".");
 		}
@@ -317,9 +317,9 @@ ScriptInstance *GDScript::instance_create(Object *p_this) {
 	return _create_instance(nullptr, 0, p_this, Object::cast_to<Reference>(p_this) != nullptr, unchecked_error);
 }
 
-PlaceHolderScriptInstance *GDScript::placeholder_instance_create(Object *p_this) {
+PlaceHolderScriptInstance *CScript::placeholder_instance_create(Object *p_this) {
 #ifdef TOOLS_ENABLED
-	PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(GDScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
+	PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(CScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
 	placeholders.insert(si);
 	_update_exports(nullptr, false, si);
 	return si;
@@ -328,21 +328,21 @@ PlaceHolderScriptInstance *GDScript::placeholder_instance_create(Object *p_this)
 #endif
 }
 
-bool GDScript::instance_has(const Object *p_this) const {
-	GDScriptLanguage::singleton->lock.lock();
+bool CScript::instance_has(const Object *p_this) const {
+	CScriptLanguage::singleton->lock.lock();
 	bool hasit = instances.has((Object *)p_this);
-	GDScriptLanguage::singleton->lock.unlock();
+	CScriptLanguage::singleton->lock.unlock();
 
 	return hasit;
 }
 
-bool GDScript::has_source_code() const {
+bool CScript::has_source_code() const {
 	return source != "";
 }
-String GDScript::get_source_code() const {
+String CScript::get_source_code() const {
 	return source;
 }
-void GDScript::set_source_code(const String &p_code) {
+void CScript::set_source_code(const String &p_code) {
 	if (source == p_code) {
 		return;
 	}
@@ -353,7 +353,7 @@ void GDScript::set_source_code(const String &p_code) {
 }
 
 #ifdef TOOLS_ENABLED
-void GDScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {
+void CScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {
 	if (base_cache.is_valid()) {
 		base_cache->_update_exports_values(values, propnames);
 	}
@@ -368,10 +368,10 @@ void GDScript::_update_exports_values(Map<StringName, Variant> &values, List<Pro
 }
 #endif
 
-bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderScriptInstance *p_instance_to_update) {
+bool CScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderScriptInstance *p_instance_to_update) {
 #ifdef TOOLS_ENABLED
 
-	static Vector<GDScript *> base_caches;
+	static Vector<CScript *> base_caches;
 	if (!p_recursive_call) {
 		base_caches.clear();
 	}
@@ -393,18 +393,18 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 			basedir = basedir.get_base_dir();
 		}
 
-		GDScriptParser parser;
+		CScriptParser parser;
 		Error err = parser.parse(source, basedir, true, path);
 
 		if (err == OK) {
-			const GDScriptParser::Node *root = parser.get_parse_tree();
-			ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, false);
+			const CScriptParser::Node *root = parser.get_parse_tree();
+			ERR_FAIL_COND_V(root->type != CScriptParser::Node::TYPE_CLASS, false);
 
-			const GDScriptParser::ClassNode *c = static_cast<const GDScriptParser::ClassNode *>(root);
+			const CScriptParser::ClassNode *c = static_cast<const CScriptParser::ClassNode *>(root);
 
 			if (base_cache.is_valid()) {
 				base_cache->inheriters_cache.erase(get_instance_id());
-				base_cache = Ref<GDScript>();
+				base_cache = Ref<CScript>();
 			}
 
 			if (c->extends_used) {
@@ -429,7 +429,7 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 
 				if (path != "") {
 					if (path != get_path()) {
-						Ref<GDScript> bf = ResourceLoader::load(path);
+						Ref<CScript> bf = ResourceLoader::load(path);
 
 						if (bf.is_valid()) {
 							base_cache = bf;
@@ -526,7 +526,7 @@ bool GDScript::_update_exports(bool *r_err, bool p_recursive_call, PlaceHolderSc
 #endif
 }
 
-void GDScript::update_exports() {
+void CScript::update_exports() {
 #ifdef TOOLS_ENABLED
 
 	bool cyclic_error = false;
@@ -539,7 +539,7 @@ void GDScript::update_exports() {
 
 	for (Set<ObjectID>::Element *E = copy.front(); E; E = E->next()) {
 		Object *id = ObjectDB::get_instance(E->get());
-		GDScript *s = Object::cast_to<GDScript>(id);
+		CScript *s = Object::cast_to<CScript>(id);
 		if (!s) {
 			continue;
 		}
@@ -549,14 +549,14 @@ void GDScript::update_exports() {
 #endif
 }
 
-void GDScript::_set_subclass_path(Ref<GDScript> &p_sc, const String &p_path) {
+void CScript::_set_subclass_path(Ref<CScript> &p_sc, const String &p_path) {
 	p_sc->path = p_path;
-	for (Map<StringName, Ref<GDScript>>::Element *E = p_sc->subclasses.front(); E; E = E->next()) {
+	for (Map<StringName, Ref<CScript>>::Element *E = p_sc->subclasses.front(); E; E = E->next()) {
 		_set_subclass_path(E->get(), p_path);
 	}
 }
 
-String GDScript::_get_debug_path() const {
+String CScript::_get_debug_path() const {
 	if ((get_path().empty() || get_path().find("::") != -1) && !get_name().empty()) {
 		return get_name() + " (" + get_path().get_slice("::", 0) + ")";
 	} else {
@@ -564,10 +564,10 @@ String GDScript::_get_debug_path() const {
 	}
 }
 
-Error GDScript::reload(bool p_keep_state) {
-	GDScriptLanguage::singleton->lock.lock();
+Error CScript::reload(bool p_keep_state) {
+	CScriptLanguage::singleton->lock.lock();
 	bool has_instances = instances.size();
-	GDScriptLanguage::singleton->lock.unlock();
+	CScriptLanguage::singleton->lock.unlock();
 
 	ERR_FAIL_COND_V(!p_keep_state && has_instances, ERR_ALREADY_IN_USE);
 
@@ -587,35 +587,35 @@ Error GDScript::reload(bool p_keep_state) {
 	}
 
 	valid = false;
-	GDScriptParser parser;
+	CScriptParser parser;
 	Error err = parser.parse(source, basedir, false, path);
 	if (err) {
 		if (ScriptDebugger::get_singleton()) {
-			GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), parser.get_error_line(), "Parser Error: " + parser.get_error());
+			CScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), parser.get_error_line(), "Parser Error: " + parser.get_error());
 		}
-		_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		_err_print_error("CScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_PARSE_ERROR);
 	}
 
 	bool can_run = ScriptServer::is_scripting_enabled() || parser.is_tool_script();
 
-	GDScriptCompiler compiler;
+	CScriptCompiler compiler;
 	err = compiler.compile(&parser, this, p_keep_state);
 
 	if (err) {
 		if (can_run) {
 			if (ScriptDebugger::get_singleton()) {
-				GDScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
+				CScriptLanguage::get_singleton()->debug_break_parse(_get_debug_path(), compiler.get_error_line(), "Parser Error: " + compiler.get_error());
 			}
-			_err_print_error("GDScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+			_err_print_error("CScript::reload", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 			ERR_FAIL_V(ERR_COMPILATION_FAILED);
 		} else {
 			return err;
 		}
 	}
 #ifdef DEBUG_ENABLED
-	for (const List<GDScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
-		const GDScriptWarning &warning = E->get();
+	for (const List<CScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
+		const CScriptWarning &warning = E->get();
 		if (ScriptDebugger::get_singleton()) {
 			Vector<ScriptLanguage::StackInfo> si;
 			ScriptDebugger::get_singleton()->send_error("", get_path(), warning.line, warning.get_name(), warning.get_message(), ERR_HANDLER_WARNING, si);
@@ -625,7 +625,7 @@ Error GDScript::reload(bool p_keep_state) {
 
 	valid = true;
 
-	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+	for (Map<StringName, Ref<CScript>>::Element *E = subclasses.front(); E; E = E->next()) {
 		_set_subclass_path(E->get(), path);
 	}
 	_clear_pending_func_states();
@@ -633,11 +633,11 @@ Error GDScript::reload(bool p_keep_state) {
 	return OK;
 }
 
-ScriptLanguage *GDScript::get_language() const {
-	return GDScriptLanguage::get_singleton();
+ScriptLanguage *CScript::get_language() const {
+	return CScriptLanguage::get_singleton();
 }
 
-void GDScript::get_constants(Map<StringName, Variant> *p_constants) {
+void CScript::get_constants(Map<StringName, Variant> *p_constants) {
 	if (p_constants) {
 		for (Map<StringName, Variant>::Element *E = constants.front(); E; E = E->next()) {
 			(*p_constants)[E->key()] = E->value();
@@ -645,7 +645,7 @@ void GDScript::get_constants(Map<StringName, Variant> *p_constants) {
 	}
 }
 
-void GDScript::get_members(Set<StringName> *p_members) {
+void CScript::get_members(Set<StringName> *p_members) {
 	if (p_members) {
 		for (Set<StringName>::Element *E = members.front(); E; E = E->next()) {
 			p_members->insert(E->get());
@@ -653,10 +653,10 @@ void GDScript::get_members(Set<StringName> *p_members) {
 	}
 }
 
-Variant GDScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
-	GDScript *top = this;
+Variant CScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	CScript *top = this;
 	while (top) {
-		Map<StringName, GDScriptFunction *>::Element *E = top->member_functions.find(p_method);
+		Map<StringName, CScriptFunction *>::Element *E = top->member_functions.find(p_method);
 		if (E) {
 			ERR_FAIL_COND_V_MSG(!E->get()->is_static(), Variant(), "Can't call non-static function '" + String(p_method) + "' in script.");
 
@@ -670,9 +670,9 @@ Variant GDScript::call(const StringName &p_method, const Variant **p_args, int p
 	return Script::call(p_method, p_args, p_argcount, r_error);
 }
 
-bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
+bool CScript::_get(const StringName &p_name, Variant &r_ret) const {
 	{
-		const GDScript *top = this;
+		const CScript *top = this;
 		while (top) {
 			{
 				const Map<StringName, Variant>::Element *E = top->constants.find(p_name);
@@ -683,7 +683,7 @@ bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
 			}
 
 			{
-				const Map<StringName, Ref<GDScript>>::Element *E = subclasses.find(p_name);
+				const Map<StringName, Ref<CScript>>::Element *E = subclasses.find(p_name);
 				if (E) {
 					r_ret = E->get();
 					return true;
@@ -692,7 +692,7 @@ bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
 			top = top->_base;
 		}
 
-		if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
+		if (p_name == CScriptLanguage::get_singleton()->strings._script_source) {
 			r_ret = get_source_code();
 			return true;
 		}
@@ -700,8 +700,8 @@ bool GDScript::_get(const StringName &p_name, Variant &r_ret) const {
 
 	return false;
 }
-bool GDScript::_set(const StringName &p_name, const Variant &p_value) {
-	if (p_name == GDScriptLanguage::get_singleton()->strings._script_source) {
+bool CScript::_set(const StringName &p_name, const Variant &p_value) {
+	if (p_name == CScriptLanguage::get_singleton()->strings._script_source) {
 		set_source_code(p_value);
 		reload();
 	} else {
@@ -711,22 +711,22 @@ bool GDScript::_set(const StringName &p_name, const Variant &p_value) {
 	return true;
 }
 
-void GDScript::_get_property_list(List<PropertyInfo> *p_properties) const {
+void CScript::_get_property_list(List<PropertyInfo> *p_properties) const {
 	p_properties->push_back(PropertyInfo(Variant::STRING, "script/source", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
 }
 
-void GDScript::_bind_methods() {
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &GDScript::_new, MethodInfo("new"));
+void CScript::_bind_methods() {
+	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "new", &CScript::_new, MethodInfo("new"));
 
-	ClassDB::bind_method(D_METHOD("get_as_byte_code"), &GDScript::get_as_byte_code);
+	ClassDB::bind_method(D_METHOD("get_as_byte_code"), &CScript::get_as_byte_code);
 }
 
-Vector<uint8_t> GDScript::get_as_byte_code() const {
-	GDScriptTokenizerBuffer tokenizer;
+Vector<uint8_t> CScript::get_as_byte_code() const {
+	CScriptTokenizerBuffer tokenizer;
 	return tokenizer.parse_code_string(source);
 };
 
-Error GDScript::load_byte_code(const String &p_path) {
+Error CScript::load_byte_code(const String &p_path) {
 	Vector<uint8_t> bytecode;
 
 	if (p_path.ends_with("gde")) {
@@ -775,31 +775,31 @@ Error GDScript::load_byte_code(const String &p_path) {
 	}
 
 	valid = false;
-	GDScriptParser parser;
+	CScriptParser parser;
 	Error err = parser.parse_bytecode(bytecode, basedir, get_path());
 	if (err) {
-		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		_err_print_error("CScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), parser.get_error_line(), ("Parse Error: " + parser.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_PARSE_ERROR);
 	}
 
-	GDScriptCompiler compiler;
+	CScriptCompiler compiler;
 	err = compiler.compile(&parser, this);
 
 	if (err) {
-		_err_print_error("GDScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
+		_err_print_error("CScript::load_byte_code", path.empty() ? "built-in" : (const char *)path.utf8().get_data(), compiler.get_error_line(), ("Compile Error: " + compiler.get_error()).utf8().get_data(), ERR_HANDLER_SCRIPT);
 		ERR_FAIL_V(ERR_COMPILATION_FAILED);
 	}
 
 	valid = true;
 
-	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+	for (Map<StringName, Ref<CScript>>::Element *E = subclasses.front(); E; E = E->next()) {
 		_set_subclass_path(E->get(), path);
 	}
 
 	return OK;
 }
 
-Error GDScript::load_source_code(const String &p_path) {
+Error CScript::load_source_code(const String &p_path) {
 	PoolVector<uint8_t> sourcef;
 	Error err;
 	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
@@ -829,11 +829,11 @@ Error GDScript::load_source_code(const String &p_path) {
 	return OK;
 }
 
-const Map<StringName, GDScriptFunction *> &GDScript::debug_get_member_functions() const {
+const Map<StringName, CScriptFunction *> &CScript::debug_get_member_functions() const {
 	return member_functions;
 }
 
-StringName GDScript::debug_get_member_by_index(int p_idx) const {
+StringName CScript::debug_get_member_by_index(int p_idx) const {
 	for (const Map<StringName, MemberInfo>::Element *E = member_indices.front(); E; E = E->next()) {
 		if (E->get().index == p_idx) {
 			return E->key();
@@ -843,17 +843,17 @@ StringName GDScript::debug_get_member_by_index(int p_idx) const {
 	return "<error>";
 }
 
-Ref<GDScript> GDScript::get_base() const {
+Ref<CScript> CScript::get_base() const {
 	return base;
 }
 
-bool GDScript::inherits_script(const Ref<Script> &p_script) const {
-	Ref<GDScript> gd = p_script;
+bool CScript::inherits_script(const Ref<Script> &p_script) const {
+	Ref<CScript> gd = p_script;
 	if (gd.is_null()) {
 		return false;
 	}
 
-	const GDScript *s = this;
+	const CScript *s = this;
 
 	while (s) {
 		if (s == p_script.ptr()) {
@@ -865,7 +865,7 @@ bool GDScript::inherits_script(const Ref<Script> &p_script) const {
 	return false;
 }
 
-bool GDScript::has_script_signal(const StringName &p_signal) const {
+bool CScript::has_script_signal(const StringName &p_signal) const {
 	if (_signals.has(p_signal)) {
 		return true;
 	}
@@ -879,7 +879,7 @@ bool GDScript::has_script_signal(const StringName &p_signal) const {
 #endif
 	return false;
 }
-void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
+void CScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 	for (const Map<StringName, Vector<StringName>>::Element *E = _signals.front(); E; E = E->next()) {
 		MethodInfo mi;
 		mi.name = E->key();
@@ -902,7 +902,7 @@ void GDScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 #endif
 }
 
-GDScript::GDScript() :
+CScript::CScript() :
 		script_list(this) {
 	valid = false;
 	subclass_count = 0;
@@ -916,20 +916,20 @@ GDScript::GDScript() :
 #endif
 
 #ifdef DEBUG_ENABLED
-	GDScriptLanguage::get_singleton()->lock.lock();
-	GDScriptLanguage::get_singleton()->script_list.add(&script_list);
-	GDScriptLanguage::get_singleton()->lock.unlock();
+	CScriptLanguage::get_singleton()->lock.lock();
+	CScriptLanguage::get_singleton()->script_list.add(&script_list);
+	CScriptLanguage::get_singleton()->lock.unlock();
 #endif
 }
 
-void GDScript::_save_orphaned_subclasses() {
+void CScript::_save_orphaned_subclasses() {
 	struct ClassRefWithName {
 		ObjectID id;
 		String fully_qualified_name;
 	};
 	Vector<ClassRefWithName> weak_subclasses;
 	// collect subclasses ObjectID and name
-	for (Map<StringName, Ref<GDScript>>::Element *E = subclasses.front(); E; E = E->next()) {
+	for (Map<StringName, Ref<CScript>>::Element *E = subclasses.front(); E; E = E->next()) {
 		E->get()->_owner = nullptr; //bye, you are no longer owned cause I died
 		ClassRefWithName subclass;
 		subclass.id = E->get()->get_instance_id();
@@ -950,23 +950,23 @@ void GDScript::_save_orphaned_subclasses() {
 			continue;
 		}
 		// subclass is not released
-		GDScriptLanguage::get_singleton()->add_orphan_subclass(subclass.fully_qualified_name, subclass.id);
+		CScriptLanguage::get_singleton()->add_orphan_subclass(subclass.fully_qualified_name, subclass.id);
 	}
 }
 
-GDScript::~GDScript() {
+CScript::~CScript() {
 	_clear_pending_func_states();
 
-	for (Map<StringName, GDScriptFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
+	for (Map<StringName, CScriptFunction *>::Element *E = member_functions.front(); E; E = E->next()) {
 		memdelete(E->get());
 	}
 
 	_save_orphaned_subclasses();
 
 #ifdef DEBUG_ENABLED
-	GDScriptLanguage::get_singleton()->lock.lock();
-	GDScriptLanguage::get_singleton()->script_list.remove(&script_list);
-	GDScriptLanguage::get_singleton()->lock.unlock();
+	CScriptLanguage::get_singleton()->lock.lock();
+	CScriptLanguage::get_singleton()->script_list.remove(&script_list);
+	CScriptLanguage::get_singleton()->lock.unlock();
 #endif
 }
 
@@ -974,12 +974,12 @@ GDScript::~GDScript() {
 //         INSTANCE         //
 //////////////////////////////
 
-bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
+bool CScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 	//member
 	{
-		const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+		const Map<StringName, CScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
 		if (E) {
-			const GDScript::MemberInfo *member = &E->get();
+			const CScript::MemberInfo *member = &E->get();
 			if (member->setter) {
 				const Variant *val = &p_value;
 				Variant::CallError err;
@@ -1009,9 +1009,9 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 		}
 	}
 
-	GDScript *sptr = script.ptr();
+	CScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._set);
+		Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(CScriptLanguage::get_singleton()->strings._set);
 		if (E) {
 			Variant name = p_name;
 			const Variant *args[2] = { &name, &p_value };
@@ -1028,15 +1028,15 @@ bool GDScriptInstance::set(const StringName &p_name, const Variant &p_value) {
 	return false;
 }
 
-bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
-	const GDScript *sptr = script.ptr();
+bool CScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
+	const CScript *sptr = script.ptr();
 	while (sptr) {
 		{
-			const Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
+			const Map<StringName, CScript::MemberInfo>::Element *E = script->member_indices.find(p_name);
 			if (E) {
 				if (E->get().getter) {
 					Variant::CallError err;
-					r_ret = const_cast<GDScriptInstance *>(this)->call(E->get().getter, nullptr, 0, err);
+					r_ret = const_cast<CScriptInstance *>(this)->call(E->get().getter, nullptr, 0, err);
 					if (err.error == Variant::CallError::CALL_OK) {
 						return true;
 					}
@@ -1047,7 +1047,7 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 		}
 
 		{
-			const GDScript *sl = sptr;
+			const CScript *sl = sptr;
 			while (sl) {
 				const Map<StringName, Variant>::Element *E = sl->constants.find(p_name);
 				if (E) {
@@ -1059,13 +1059,13 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 		}
 
 		{
-			const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get);
+			const Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(CScriptLanguage::get_singleton()->strings._get);
 			if (E) {
 				Variant name = p_name;
 				const Variant *args[1] = { &name };
 
 				Variant::CallError err;
-				Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), (const Variant **)args, 1, err);
+				Variant ret = const_cast<CScriptFunction *>(E->get())->call(const_cast<CScriptInstance *>(this), (const Variant **)args, 1, err);
 				if (err.error == Variant::CallError::CALL_OK && ret.get_type() != Variant::NIL) {
 					r_ret = ret;
 					return true;
@@ -1078,8 +1078,8 @@ bool GDScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 	return false;
 }
 
-Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
-	const GDScript *sptr = script.ptr();
+Variant::Type CScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
+	const CScript *sptr = script.ptr();
 	while (sptr) {
 		if (sptr->member_info.has(p_name)) {
 			if (r_is_valid) {
@@ -1096,17 +1096,17 @@ Variant::Type GDScriptInstance::get_property_type(const StringName &p_name, bool
 	return Variant::NIL;
 }
 
-void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
+void CScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 	// exported members, not done yet!
 
-	const GDScript *sptr = script.ptr();
+	const CScript *sptr = script.ptr();
 	List<PropertyInfo> props;
 
 	while (sptr) {
-		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._get_property_list);
+		const Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(CScriptLanguage::get_singleton()->strings._get_property_list);
 		if (E) {
 			Variant::CallError err;
-			Variant ret = const_cast<GDScriptFunction *>(E->get())->call(const_cast<GDScriptInstance *>(this), nullptr, 0, err);
+			Variant ret = const_cast<CScriptFunction *>(E->get())->call(const_cast<CScriptInstance *>(this), nullptr, 0, err);
 			if (err.error == Variant::CallError::CALL_OK) {
 				ERR_FAIL_COND_MSG(ret.get_type() != Variant::ARRAY, "Wrong type for _get_property_list, must be an array of dictionaries.");
 
@@ -1137,9 +1137,9 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 
 		//instance a fake script for editing the values
 
-		Vector<_GDScriptMemberSort> msort;
+		Vector<_CScriptMemberSort> msort;
 		for (Map<StringName, PropertyInfo>::Element *F = sptr->member_info.front(); F; F = F->next()) {
-			_GDScriptMemberSort ms;
+			_CScriptMemberSort ms;
 			ERR_CONTINUE(!sptr->member_indices.has(F->key()));
 			ms.index = sptr->member_indices[F->key()].index;
 			ms.name = F->key();
@@ -1160,10 +1160,10 @@ void GDScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const
 	}
 }
 
-void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
-	const GDScript *sptr = script.ptr();
+void CScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
+	const CScript *sptr = script.ptr();
 	while (sptr) {
-		for (Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.front(); E; E = E->next()) {
+		for (Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.front(); E; E = E->next()) {
 			MethodInfo mi;
 			mi.name = E->key();
 			mi.flags |= METHOD_FLAG_FROM_SCRIPT;
@@ -1176,10 +1176,10 @@ void GDScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-bool GDScriptInstance::has_method(const StringName &p_method) const {
-	const GDScript *sptr = script.ptr();
+bool CScriptInstance::has_method(const StringName &p_method) const {
+	const CScript *sptr = script.ptr();
 	while (sptr) {
-		const Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		const Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E) {
 			return true;
 		}
@@ -1188,10 +1188,10 @@ bool GDScriptInstance::has_method(const StringName &p_method) const {
 
 	return false;
 }
-Variant GDScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
-	GDScript *sptr = script.ptr();
+Variant CScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+	CScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E) {
 			return E->get()->call(this, p_args, p_argcount, r_error);
 		}
@@ -1201,12 +1201,12 @@ Variant GDScriptInstance::call(const StringName &p_method, const Variant **p_arg
 	return Variant();
 }
 
-void GDScriptInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
-	GDScript *sptr = script.ptr();
+void CScriptInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
+	CScript *sptr = script.ptr();
 	Variant::CallError ce;
 
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+		Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
 		if (E) {
 			E->get()->call(this, p_args, p_argcount, ce);
 		}
@@ -1214,33 +1214,33 @@ void GDScriptInstance::call_multilevel(const StringName &p_method, const Variant
 	}
 }
 
-void GDScriptInstance::_ml_call_reversed(GDScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
+void CScriptInstance::_ml_call_reversed(CScript *sptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
 	if (sptr->_base) {
 		_ml_call_reversed(sptr->_base, p_method, p_args, p_argcount);
 	}
 
 	Variant::CallError ce;
 
-	Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
+	Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(p_method);
 	if (E) {
 		E->get()->call(this, p_args, p_argcount, ce);
 	}
 }
 
-void GDScriptInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
+void CScriptInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
 	if (script.ptr()) {
 		_ml_call_reversed(script.ptr(), p_method, p_args, p_argcount);
 	}
 }
 
-void GDScriptInstance::notification(int p_notification) {
+void CScriptInstance::notification(int p_notification) {
 	//notification is not virtual, it gets called at ALL levels just like in C.
 	Variant value = p_notification;
 	const Variant *args[1] = { &value };
 
-	GDScript *sptr = script.ptr();
+	CScript *sptr = script.ptr();
 	while (sptr) {
-		Map<StringName, GDScriptFunction *>::Element *E = sptr->member_functions.find(GDScriptLanguage::get_singleton()->strings._notification);
+		Map<StringName, CScriptFunction *>::Element *E = sptr->member_functions.find(CScriptLanguage::get_singleton()->strings._notification);
 		if (E) {
 			Variant::CallError err;
 			E->get()->call(this, args, 1, err);
@@ -1252,7 +1252,7 @@ void GDScriptInstance::notification(int p_notification) {
 	}
 }
 
-String GDScriptInstance::to_string(bool *r_valid) {
+String CScriptInstance::to_string(bool *r_valid) {
 	if (has_method(CoreStringNames::get_singleton()->_to_string)) {
 		Variant::CallError ce;
 		Variant ret = call(CoreStringNames::get_singleton()->_to_string, nullptr, 0, ce);
@@ -1275,19 +1275,19 @@ String GDScriptInstance::to_string(bool *r_valid) {
 	return String();
 }
 
-Ref<Script> GDScriptInstance::get_script() const {
+Ref<Script> CScriptInstance::get_script() const {
 	return script;
 }
 
-ScriptLanguage *GDScriptInstance::get_language() {
-	return GDScriptLanguage::get_singleton();
+ScriptLanguage *CScriptInstance::get_language() {
+	return CScriptLanguage::get_singleton();
 }
 
-MultiplayerAPI::RPCMode GDScriptInstance::get_rpc_mode(const StringName &p_method) const {
-	const GDScript *cscript = script.ptr();
+MultiplayerAPI::RPCMode CScriptInstance::get_rpc_mode(const StringName &p_method) const {
+	const CScript *cscript = script.ptr();
 
 	while (cscript) {
-		const Map<StringName, GDScriptFunction *>::Element *E = cscript->member_functions.find(p_method);
+		const Map<StringName, CScriptFunction *>::Element *E = cscript->member_functions.find(p_method);
 		if (E) {
 			if (E->get()->get_rpc_mode() != MultiplayerAPI::RPC_MODE_DISABLED) {
 				return E->get()->get_rpc_mode();
@@ -1299,11 +1299,11 @@ MultiplayerAPI::RPCMode GDScriptInstance::get_rpc_mode(const StringName &p_metho
 	return MultiplayerAPI::RPC_MODE_DISABLED;
 }
 
-MultiplayerAPI::RPCMode GDScriptInstance::get_rset_mode(const StringName &p_variable) const {
-	const GDScript *cscript = script.ptr();
+MultiplayerAPI::RPCMode CScriptInstance::get_rset_mode(const StringName &p_variable) const {
+	const CScript *cscript = script.ptr();
 
 	while (cscript) {
-		const Map<StringName, GDScript::MemberInfo>::Element *E = cscript->member_indices.find(p_variable);
+		const Map<StringName, CScript::MemberInfo>::Element *E = cscript->member_indices.find(p_variable);
 		if (E) {
 			if (E->get().rpc_mode) {
 				return E->get().rpc_mode;
@@ -1315,7 +1315,7 @@ MultiplayerAPI::RPCMode GDScriptInstance::get_rset_mode(const StringName &p_vari
 	return MultiplayerAPI::RPC_MODE_DISABLED;
 }
 
-void GDScriptInstance::reload_members() {
+void CScriptInstance::reload_members() {
 #ifdef DEBUG_ENABLED
 
 	members.resize(script->member_indices.size()); //resize
@@ -1324,7 +1324,7 @@ void GDScriptInstance::reload_members() {
 	new_members.resize(script->member_indices.size());
 
 	//pass the values to the new indices
-	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+	for (Map<StringName, CScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
 		if (member_indices_cache.has(E->key())) {
 			Variant value = members[member_indices_cache[E->key()]];
 			new_members.write[E->get().index] = value;
@@ -1336,24 +1336,24 @@ void GDScriptInstance::reload_members() {
 
 	//pass the values to the new indices
 	member_indices_cache.clear();
-	for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+	for (Map<StringName, CScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
 		member_indices_cache[E->key()] = E->get().index;
 	}
 
 #endif
 }
 
-GDScriptInstance::GDScriptInstance() {
+CScriptInstance::CScriptInstance() {
 	owner = nullptr;
 	base_ref = false;
 }
 
-GDScriptInstance::~GDScriptInstance() {
-	GDScriptLanguage::singleton->lock.lock();
+CScriptInstance::~CScriptInstance() {
+	CScriptLanguage::singleton->lock.lock();
 
-	while (SelfList<GDScriptFunctionState> *E = pending_func_states.first()) {
+	while (SelfList<CScriptFunctionState> *E = pending_func_states.first()) {
 		// Order matters since clearing the stack may already cause
-		// the GDSCriptFunctionState to be destroyed and thus removed from the list.
+		// the CSCriptFunctionState to be destroyed and thus removed from the list.
 		pending_func_states.remove(E);
 		E->self()->_clear_stack();
 	}
@@ -1362,20 +1362,20 @@ GDScriptInstance::~GDScriptInstance() {
 		script->instances.erase(owner);
 	}
 
-	GDScriptLanguage::singleton->lock.unlock();
+	CScriptLanguage::singleton->lock.unlock();
 }
 
 /************* SCRIPT LANGUAGE **************/
 
-GDScriptLanguage *GDScriptLanguage::singleton = nullptr;
+CScriptLanguage *CScriptLanguage::singleton = nullptr;
 
-String GDScriptLanguage::get_name() const {
-	return "GDScript";
+String CScriptLanguage::get_name() const {
+	return "CScript";
 }
 
 /* LANGUAGE FUNCTIONS */
 
-void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) {
+void CScriptLanguage::_add_global(const StringName &p_name, const Variant &p_value) {
 	if (globals.has(p_name)) {
 		//overwrite existing
 		global_array.write[globals[p_name]] = p_value;
@@ -1386,20 +1386,20 @@ void GDScriptLanguage::_add_global(const StringName &p_name, const Variant &p_va
 	_global_array = global_array.ptrw();
 }
 
-void GDScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
+void CScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
 	_add_global(p_variable, p_value);
 }
 
-void GDScriptLanguage::add_named_global_constant(const StringName &p_name, const Variant &p_value) {
+void CScriptLanguage::add_named_global_constant(const StringName &p_name, const Variant &p_value) {
 	named_globals[p_name] = p_value;
 }
 
-void GDScriptLanguage::remove_named_global_constant(const StringName &p_name) {
+void CScriptLanguage::remove_named_global_constant(const StringName &p_name) {
 	ERR_FAIL_COND(!named_globals.has(p_name));
 	named_globals.erase(p_name);
 }
 
-void GDScriptLanguage::init() {
+void CScriptLanguage::init() {
 	//populate global constants
 	int gcc = GlobalConstants::get_global_constant_count();
 	for (int i = 0; i < gcc; i++) {
@@ -1425,7 +1425,7 @@ void GDScriptLanguage::init() {
 		if (globals.has(n)) {
 			continue;
 		}
-		Ref<GDScriptNativeClass> nc = memnew(GDScriptNativeClass(E->get()));
+		Ref<CScriptNativeClass> nc = memnew(CScriptNativeClass(E->get()));
 		_add_global(n, nc);
 	}
 
@@ -1438,24 +1438,24 @@ void GDScriptLanguage::init() {
 	}
 }
 
-String GDScriptLanguage::get_type() const {
-	return "GDScript";
+String CScriptLanguage::get_type() const {
+	return "CScript";
 }
-String GDScriptLanguage::get_extension() const {
+String CScriptLanguage::get_extension() const {
 	return "gd";
 }
-Error GDScriptLanguage::execute_file(const String &p_path) {
+Error CScriptLanguage::execute_file(const String &p_path) {
 	// ??
 	return OK;
 }
-void GDScriptLanguage::finish() {
+void CScriptLanguage::finish() {
 }
 
-void GDScriptLanguage::profiling_start() {
+void CScriptLanguage::profiling_start() {
 #ifdef DEBUG_ENABLED
 	lock.lock();
 
-	SelfList<GDScriptFunction> *elem = function_list.first();
+	SelfList<CScriptFunction> *elem = function_list.first();
 	while (elem) {
 		elem->self()->profile.call_count = 0;
 		elem->self()->profile.self_time = 0;
@@ -1474,7 +1474,7 @@ void GDScriptLanguage::profiling_start() {
 #endif
 }
 
-void GDScriptLanguage::profiling_stop() {
+void CScriptLanguage::profiling_stop() {
 #ifdef DEBUG_ENABLED
 	lock.lock();
 	profiling = false;
@@ -1482,12 +1482,12 @@ void GDScriptLanguage::profiling_stop() {
 #endif
 }
 
-int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
+int CScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
 	int current = 0;
 #ifdef DEBUG_ENABLED
 	lock.lock();
 
-	SelfList<GDScriptFunction> *elem = function_list.first();
+	SelfList<CScriptFunction> *elem = function_list.first();
 	while (elem) {
 		if (current >= p_info_max) {
 			break;
@@ -1506,13 +1506,13 @@ int GDScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr,
 	return current;
 }
 
-int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
+int CScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
 	int current = 0;
 
 #ifdef DEBUG_ENABLED
 	lock.lock();
 
-	SelfList<GDScriptFunction> *elem = function_list.first();
+	SelfList<CScriptFunction> *elem = function_list.first();
 	while (elem) {
 		if (current >= p_info_max) {
 			break;
@@ -1533,13 +1533,13 @@ int GDScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_
 	return current;
 }
 
-struct GDScriptDepSort {
+struct CScriptDepSort {
 	//must support sorting so inheritance works properly (parent must be reloaded first)
-	bool operator()(const Ref<GDScript> &A, const Ref<GDScript> &B) const {
+	bool operator()(const Ref<CScript> &A, const Ref<CScript> &B) const {
 		if (A == B) {
 			return false; //shouldn't happen but..
 		}
-		const GDScript *I = B->get_base().ptr();
+		const CScript *I = B->get_base().ptr();
 		while (I) {
 			if (I == A.ptr()) {
 				// A is a base of B
@@ -1553,18 +1553,18 @@ struct GDScriptDepSort {
 	}
 };
 
-void GDScriptLanguage::reload_all_scripts() {
+void CScriptLanguage::reload_all_scripts() {
 #ifdef DEBUG_ENABLED
-	print_verbose("GDScript: Reloading all scripts");
+	print_verbose("CScript: Reloading all scripts");
 	lock.lock();
 
-	List<Ref<GDScript>> scripts;
+	List<Ref<CScript>> scripts;
 
-	SelfList<GDScript> *elem = script_list.first();
+	SelfList<CScript> *elem = script_list.first();
 	while (elem) {
 		if (elem->self()->get_path().is_resource_file()) {
-			print_verbose("GDScript: Found: " + elem->self()->get_path());
-			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+			print_verbose("CScript: Found: " + elem->self()->get_path());
+			scripts.push_back(Ref<CScript>(elem->self())); //cast to gdscript to avoid being erased by accident
 		}
 		elem = elem->next();
 	}
@@ -1573,27 +1573,27 @@ void GDScriptLanguage::reload_all_scripts() {
 
 	//as scripts are going to be reloaded, must proceed without locking here
 
-	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+	scripts.sort_custom<CScriptDepSort>(); //update in inheritance dependency order
 
-	for (List<Ref<GDScript>>::Element *E = scripts.front(); E; E = E->next()) {
-		print_verbose("GDScript: Reloading: " + E->get()->get_path());
+	for (List<Ref<CScript>>::Element *E = scripts.front(); E; E = E->next()) {
+		print_verbose("CScript: Reloading: " + E->get()->get_path());
 		E->get()->load_source_code(E->get()->get_path());
 		E->get()->reload(true);
 	}
 #endif
 }
 
-void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
+void CScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
 #ifdef DEBUG_ENABLED
 
 	lock.lock();
 
-	List<Ref<GDScript>> scripts;
+	List<Ref<CScript>> scripts;
 
-	SelfList<GDScript> *elem = script_list.first();
+	SelfList<CScript> *elem = script_list.first();
 	while (elem) {
 		if (elem->self()->get_path().is_resource_file()) {
-			scripts.push_back(Ref<GDScript>(elem->self())); //cast to gdscript to avoid being erased by accident
+			scripts.push_back(Ref<CScript>(elem->self())); //cast to gdscript to avoid being erased by accident
 		}
 		elem = elem->next();
 	}
@@ -1602,13 +1602,13 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 
 	//when someone asks you why dynamically typed languages are easier to write....
 
-	Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
+	Map<Ref<CScript>, Map<ObjectID, List<Pair<StringName, Variant>>>> to_reload;
 
 	//as scripts are going to be reloaded, must proceed without locking here
 
-	scripts.sort_custom<GDScriptDepSort>(); //update in inheritance dependency order
+	scripts.sort_custom<CScriptDepSort>(); //update in inheritance dependency order
 
-	for (List<Ref<GDScript>>::Element *E = scripts.front(); E; E = E->next()) {
+	for (List<Ref<CScript>>::Element *E = scripts.front(); E; E = E->next()) {
 		bool reload = E->get() == p_script || to_reload.has(E->get()->get_base());
 
 		if (!reload) {
@@ -1658,8 +1658,8 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 		}
 	}
 
-	for (Map<Ref<GDScript>, Map<ObjectID, List<Pair<StringName, Variant>>>>::Element *E = to_reload.front(); E; E = E->next()) {
-		Ref<GDScript> scr = E->key();
+	for (Map<Ref<CScript>, Map<ObjectID, List<Pair<StringName, Variant>>>>::Element *E = to_reload.front(); E; E = E->next()) {
+		Ref<CScript> scr = E->key();
 		scr->reload(p_soft_reload);
 
 		//restore state if saved
@@ -1707,14 +1707,14 @@ void GDScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_so
 #endif
 }
 
-void GDScriptLanguage::frame() {
+void CScriptLanguage::frame() {
 	calls = 0;
 
 #ifdef DEBUG_ENABLED
 	if (profiling) {
 		lock.lock();
 
-		SelfList<GDScriptFunction> *elem = function_list.first();
+		SelfList<CScriptFunction> *elem = function_list.first();
 		while (elem) {
 			elem->self()->profile.last_frame_call_count = elem->self()->profile.frame_call_count;
 			elem->self()->profile.last_frame_self_time = elem->self()->profile.frame_self_time;
@@ -1732,7 +1732,7 @@ void GDScriptLanguage::frame() {
 }
 
 /* EDITOR FUNCTIONS */
-void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
+void CScriptLanguage::get_reserved_words(List<String> *p_words) const {
 	static const char *_reserved_words[] = {
 		// operators
 		"and",
@@ -1802,12 +1802,12 @@ void GDScriptLanguage::get_reserved_words(List<String> *p_words) const {
 		w++;
 	}
 
-	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
-		p_words->push_back(GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i)));
+	for (int i = 0; i < CScriptFunctions::FUNC_MAX; i++) {
+		p_words->push_back(CScriptFunctions::get_func_name(CScriptFunctions::Function(i)));
 	}
 }
 
-bool GDScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+bool CScriptLanguage::is_control_flow_keyword(String p_keyword) const {
 	return p_keyword == "break" ||
 			p_keyword == "continue" ||
 			p_keyword == "elif" ||
@@ -1820,11 +1820,11 @@ bool GDScriptLanguage::is_control_flow_keyword(String p_keyword) const {
 			p_keyword == "while";
 }
 
-bool GDScriptLanguage::handles_global_class_type(const String &p_type) const {
-	return p_type == "GDScript";
+bool CScriptLanguage::handles_global_class_type(const String &p_type) const {
+	return p_type == "CScript";
 }
 
-String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_base_type, String *r_icon_path) const {
+String CScriptLanguage::get_global_class_name(const String &p_path, String *r_base_type, String *r_icon_path) const {
 	PoolVector<uint8_t> sourcef;
 	Error err;
 	FileAccessRef f = FileAccess::open(p_path, FileAccess::READ, &err);
@@ -1834,11 +1834,11 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 
 	String source = f->get_as_utf8_string();
 
-	GDScriptParser parser;
+	CScriptParser parser;
 	parser.parse(source, p_path.get_base_dir(), true, p_path, false, nullptr, true);
 
-	if (parser.get_parse_tree() && parser.get_parse_tree()->type == GDScriptParser::Node::TYPE_CLASS) {
-		const GDScriptParser::ClassNode *c = static_cast<const GDScriptParser::ClassNode *>(parser.get_parse_tree());
+	if (parser.get_parse_tree() && parser.get_parse_tree()->type == CScriptParser::Node::TYPE_CLASS) {
+		const CScriptParser::ClassNode *c = static_cast<const CScriptParser::ClassNode *>(parser.get_parse_tree());
 		if (r_icon_path) {
 			if (c->icon_path.empty() || c->icon_path.is_abs_path()) {
 				*r_icon_path = c->icon_path;
@@ -1847,9 +1847,9 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 			}
 		}
 		if (r_base_type) {
-			const GDScriptParser::ClassNode *subclass = c;
+			const CScriptParser::ClassNode *subclass = c;
 			String path = p_path;
-			GDScriptParser subparser;
+			CScriptParser subparser;
 			while (subclass) {
 				if (subclass->extends_used) {
 					if (subclass->extends_file) {
@@ -1878,15 +1878,15 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 								break;
 							}
 							path = subpath;
-							if (!subparser.get_parse_tree() || subparser.get_parse_tree()->type != GDScriptParser::Node::TYPE_CLASS) {
+							if (!subparser.get_parse_tree() || subparser.get_parse_tree()->type != CScriptParser::Node::TYPE_CLASS) {
 								break;
 							}
-							subclass = static_cast<const GDScriptParser::ClassNode *>(subparser.get_parse_tree());
+							subclass = static_cast<const CScriptParser::ClassNode *>(subparser.get_parse_tree());
 
 							while (extend_classes.size() > 0) {
 								bool found = false;
 								for (int i = 0; i < subclass->subclasses.size(); i++) {
-									const GDScriptParser::ClassNode *inner_class = subclass->subclasses[i];
+									const CScriptParser::ClassNode *inner_class = subclass->subclasses[i];
 									if (inner_class->name == extend_classes[0]) {
 										extend_classes.remove(0);
 										found = true;
@@ -1919,7 +1919,7 @@ String GDScriptLanguage::get_global_class_name(const String &p_path, String *r_b
 }
 
 #ifdef DEBUG_ENABLED
-String GDScriptWarning::get_message() const {
+String CScriptWarning::get_message() const {
 #define CHECK_SYMBOLS(m_amount) ERR_FAIL_COND_V(symbols.size() < m_amount, String());
 
 	switch (code) {
@@ -1963,7 +1963,7 @@ String GDScriptWarning::get_message() const {
 		} break;
 		case FUNCTION_MAY_YIELD: {
 			CHECK_SYMBOLS(1);
-			return "Assigned variable is typed but the function '" + symbols[0] + "()' may yield and return a GDScriptFunctionState instead.";
+			return "Assigned variable is typed but the function '" + symbols[0] + "()' may yield and return a CScriptFunctionState instead.";
 		} break;
 		case VARIABLE_CONFLICTS_FUNCTION: {
 			CHECK_SYMBOLS(1);
@@ -2033,16 +2033,16 @@ String GDScriptWarning::get_message() const {
 		case WARNING_MAX:
 			break; // Can't happen, but silences warning
 	}
-	ERR_FAIL_V_MSG(String(), "Invalid GDScript warning code: " + get_name_from_code(code) + ".");
+	ERR_FAIL_V_MSG(String(), "Invalid CScript warning code: " + get_name_from_code(code) + ".");
 
 #undef CHECK_SYMBOLS
 }
 
-String GDScriptWarning::get_name() const {
+String CScriptWarning::get_name() const {
 	return get_name_from_code(code);
 }
 
-String GDScriptWarning::get_name_from_code(Code p_code) {
+String CScriptWarning::get_name_from_code(Code p_code) {
 	ERR_FAIL_COND_V(p_code < 0 || p_code >= WARNING_MAX, String());
 
 	static const char *names[] = {
@@ -2080,19 +2080,19 @@ String GDScriptWarning::get_name_from_code(Code p_code) {
 	return names[(int)p_code];
 }
 
-GDScriptWarning::Code GDScriptWarning::get_code_from_name(const String &p_name) {
+CScriptWarning::Code CScriptWarning::get_code_from_name(const String &p_name) {
 	for (int i = 0; i < WARNING_MAX; i++) {
 		if (get_name_from_code((Code)i) == p_name) {
 			return (Code)i;
 		}
 	}
 
-	ERR_FAIL_V_MSG(WARNING_MAX, "Invalid GDScript warning name: " + p_name);
+	ERR_FAIL_V_MSG(WARNING_MAX, "Invalid CScript warning name: " + p_name);
 }
 
 #endif // DEBUG_ENABLED
 
-GDScriptLanguage::GDScriptLanguage() {
+CScriptLanguage::CScriptLanguage() {
 	calls = 0;
 	ERR_FAIL_COND(singleton);
 	singleton = this;
@@ -2128,37 +2128,37 @@ GDScriptLanguage::GDScriptLanguage() {
 	GLOBAL_DEF("debug/gdscript/warnings/treat_warnings_as_errors", false);
 	GLOBAL_DEF("debug/gdscript/warnings/exclude_addons", true);
 	GLOBAL_DEF("debug/gdscript/completion/autocomplete_setters_and_getters", false);
-	for (int i = 0; i < (int)GDScriptWarning::WARNING_MAX; i++) {
-		String warning = GDScriptWarning::get_name_from_code((GDScriptWarning::Code)i).to_lower();
-		bool default_enabled = !warning.begins_with("unsafe_") && i != GDScriptWarning::UNUSED_CLASS_VARIABLE;
+	for (int i = 0; i < (int)CScriptWarning::WARNING_MAX; i++) {
+		String warning = CScriptWarning::get_name_from_code((CScriptWarning::Code)i).to_lower();
+		bool default_enabled = !warning.begins_with("unsafe_") && i != CScriptWarning::UNUSED_CLASS_VARIABLE;
 		GLOBAL_DEF("debug/gdscript/warnings/" + warning, default_enabled);
 	}
 #endif // DEBUG_ENABLED
 }
 
-GDScriptLanguage::~GDScriptLanguage() {
+CScriptLanguage::~CScriptLanguage() {
 	if (_call_stack) {
 		memdelete_arr(_call_stack);
 	}
 
 	// Clear dependencies between scripts, to ensure cyclic references are broken (to avoid leaks at exit).
-	SelfList<GDScript> *s = script_list.first();
+	SelfList<CScript> *s = script_list.first();
 	while (s) {
-		GDScript *script = s->self();
+		CScript *script = s->self();
 		// This ensures the current script is not released before we can check what's the next one
 		// in the list (we can't get the next upfront because we don't know if the reference breaking
 		// will cause it -or any other after it, for that matter- to be released so the next one
 		// is not the same as before).
 		script->reference();
 
-		for (Map<StringName, GDScriptFunction *>::Element *E = script->member_functions.front(); E; E = E->next()) {
-			GDScriptFunction *func = E->get();
+		for (Map<StringName, CScriptFunction *>::Element *E = script->member_functions.front(); E; E = E->next()) {
+			CScriptFunction *func = E->get();
 			for (int i = 0; i < func->argument_types.size(); i++) {
 				func->argument_types.write[i].script_type_ref = Ref<Script>();
 			}
 			func->return_type.script_type_ref = Ref<Script>();
 		}
-		for (Map<StringName, GDScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
+		for (Map<StringName, CScript::MemberInfo>::Element *E = script->member_indices.front(); E; E = E->next()) {
 			E->get().data_type.script_type_ref = Ref<Script>();
 		}
 
@@ -2169,34 +2169,34 @@ GDScriptLanguage::~GDScriptLanguage() {
 	singleton = nullptr;
 }
 
-void GDScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass) {
+void CScriptLanguage::add_orphan_subclass(const String &p_qualified_name, const ObjectID &p_subclass) {
 	orphan_subclasses[p_qualified_name] = p_subclass;
 }
 
-Ref<GDScript> GDScriptLanguage::get_orphan_subclass(const String &p_qualified_name) {
+Ref<CScript> CScriptLanguage::get_orphan_subclass(const String &p_qualified_name) {
 	Map<String, ObjectID>::Element *orphan_subclass_element = orphan_subclasses.find(p_qualified_name);
 	if (!orphan_subclass_element) {
-		return Ref<GDScript>();
+		return Ref<CScript>();
 	}
 	ObjectID orphan_subclass = orphan_subclass_element->get();
 	Object *obj = ObjectDB::get_instance(orphan_subclass);
 	orphan_subclasses.erase(orphan_subclass_element);
 	if (!obj) {
-		return Ref<GDScript>();
+		return Ref<CScript>();
 	}
-	return Ref<GDScript>(Object::cast_to<GDScript>(obj));
+	return Ref<CScript>(Object::cast_to<CScript>(obj));
 }
 
 /*************** RESOURCE ***************/
 
-RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+RES ResourceFormatLoaderCScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	if (r_error) {
 		*r_error = ERR_FILE_CANT_OPEN;
 	}
 
-	GDScript *script = memnew(GDScript);
+	CScript *script = memnew(CScript);
 
-	Ref<GDScript> scriptres(script);
+	Ref<CScript> scriptres(script);
 
 	if (p_path.ends_with(".gde") || p_path.ends_with(".gdc")) {
 		script->set_script_path(p_original_path); // script needs this.
@@ -2220,25 +2220,25 @@ RES ResourceFormatLoaderGDScript::load(const String &p_path, const String &p_ori
 	return scriptres;
 }
 
-void ResourceFormatLoaderGDScript::get_recognized_extensions(List<String> *p_extensions) const {
+void ResourceFormatLoaderCScript::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_back("gd");
 	p_extensions->push_back("gdc");
 	p_extensions->push_back("gde");
 }
 
-bool ResourceFormatLoaderGDScript::handles_type(const String &p_type) const {
-	return (p_type == "Script" || p_type == "GDScript");
+bool ResourceFormatLoaderCScript::handles_type(const String &p_type) const {
+	return (p_type == "Script" || p_type == "CScript");
 }
 
-String ResourceFormatLoaderGDScript::get_resource_type(const String &p_path) const {
+String ResourceFormatLoaderCScript::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
 	if (el == "gd" || el == "gdc" || el == "gde") {
-		return "GDScript";
+		return "CScript";
 	}
 	return "";
 }
 
-void ResourceFormatLoaderGDScript::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
+void ResourceFormatLoaderCScript::get_dependencies(const String &p_path, List<String> *p_dependencies, bool p_add_types) {
 	FileAccessRef file = FileAccess::open(p_path, FileAccess::READ);
 	ERR_FAIL_COND_MSG(!file, "Cannot open file '" + p_path + "'.");
 
@@ -2247,7 +2247,7 @@ void ResourceFormatLoaderGDScript::get_dependencies(const String &p_path, List<S
 		return;
 	}
 
-	GDScriptParser parser;
+	CScriptParser parser;
 	if (OK != parser.parse(source, p_path.get_base_dir(), true, p_path, false, nullptr, true)) {
 		return;
 	}
@@ -2257,8 +2257,8 @@ void ResourceFormatLoaderGDScript::get_dependencies(const String &p_path, List<S
 	}
 }
 
-Error ResourceFormatSaverGDScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
-	Ref<GDScript> sqscr = p_resource;
+Error ResourceFormatSaverCScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
+	Ref<CScript> sqscr = p_resource;
 	ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
 
 	String source = sqscr->get_source_code();
@@ -2266,7 +2266,7 @@ Error ResourceFormatSaverGDScript::save(const String &p_path, const RES &p_resou
 	Error err;
 	FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err);
 
-	ERR_FAIL_COND_V_MSG(err, err, "Cannot save GDScript file '" + p_path + "'.");
+	ERR_FAIL_COND_V_MSG(err, err, "Cannot save CScript file '" + p_path + "'.");
 
 	file->store_string(source);
 	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
@@ -2277,17 +2277,17 @@ Error ResourceFormatSaverGDScript::save(const String &p_path, const RES &p_resou
 	memdelete(file);
 
 	if (ScriptServer::is_reload_scripts_on_save_enabled()) {
-		GDScriptLanguage::get_singleton()->reload_tool_script(p_resource, false);
+		CScriptLanguage::get_singleton()->reload_tool_script(p_resource, false);
 	}
 
 	return OK;
 }
 
-void ResourceFormatSaverGDScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
-	if (Object::cast_to<GDScript>(*p_resource)) {
+void ResourceFormatSaverCScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
+	if (Object::cast_to<CScript>(*p_resource)) {
 		p_extensions->push_back("gd");
 	}
 }
-bool ResourceFormatSaverGDScript::recognize(const RES &p_resource) const {
-	return Object::cast_to<GDScript>(*p_resource) != nullptr;
+bool ResourceFormatSaverCScript::recognize(const RES &p_resource) const {
+	return Object::cast_to<CScript>(*p_resource) != nullptr;
 }
diff --git a/modules/cscript/cscript.h b/modules/cscript/cscript.h
index d8ad383c3..9fdabb1d8 100644
--- a/modules/cscript/cscript.h
+++ b/modules/cscript/cscript.h
@@ -35,8 +35,8 @@
 #include "core/script_language.h"
 #include "cscript_function.h"
 
-class GDScriptNativeClass : public Reference {
-	GDCLASS(GDScriptNativeClass, Reference);
+class CScriptNativeClass : public Reference {
+	GDCLASS(CScriptNativeClass, Reference);
 
 	StringName name;
 
@@ -48,11 +48,11 @@ public:
 	_FORCE_INLINE_ const StringName &get_name() const { return name; }
 	Variant _new();
 	Object *instance();
-	GDScriptNativeClass(const StringName &p_name);
+	CScriptNativeClass(const StringName &p_name);
 };
 
-class GDScript : public Script {
-	GDCLASS(GDScript, Script);
+class CScript : public Script {
+	GDCLASS(CScript, Script);
 	bool tool;
 	bool valid;
 
@@ -61,25 +61,25 @@ class GDScript : public Script {
 		StringName setter;
 		StringName getter;
 		MultiplayerAPI::RPCMode rpc_mode;
-		GDScriptDataType data_type;
+		CScriptDataType data_type;
 	};
 
-	friend class GDScriptInstance;
-	friend class GDScriptFunction;
-	friend class GDScriptCompiler;
-	friend class GDScriptFunctions;
-	friend class GDScriptLanguage;
+	friend class CScriptInstance;
+	friend class CScriptFunction;
+	friend class CScriptCompiler;
+	friend class CScriptFunctions;
+	friend class CScriptLanguage;
 
-	Ref<GDScriptNativeClass> native;
-	Ref<GDScript> base;
-	GDScript *_base; //fast pointer access
-	GDScript *_owner; //for subclasses
+	Ref<CScriptNativeClass> native;
+	Ref<CScript> base;
+	CScript *_base; //fast pointer access
+	CScript *_owner; //for subclasses
 
 	Set<StringName> members; //members are just indices to the instanced script.
 	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, Ref<GDScript>> subclasses;
+	Map<StringName, Ref<CScript>> subclasses;
 	Map<StringName, Vector<StringName>> _signals;
 
 #ifdef TOOLS_ENABLED
@@ -90,7 +90,7 @@ class GDScript : public Script {
 
 	List<PropertyInfo> members_cache;
 	Map<StringName, Variant> member_default_values_cache;
-	Ref<GDScript> base_cache;
+	Ref<CScript> base_cache;
 	Set<ObjectID> inheriters_cache;
 	bool source_changed_cache;
 	bool placeholder_fallback_enabled;
@@ -99,7 +99,7 @@ class GDScript : public Script {
 #endif
 	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;
 	Set<Object *> instances;
@@ -108,14 +108,14 @@ class GDScript : public Script {
 	String path;
 	String 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();
 
-	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;
 
 #ifdef TOOLS_ENABLED
@@ -151,7 +151,7 @@ public:
 
 	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;
 	}
 	const Map<StringName, Variant> &get_constants() const {
@@ -160,14 +160,14 @@ public:
 	const Set<StringName> &get_members() const {
 		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));
 		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;
 	}
-	const Ref<GDScriptNativeClass> &get_native() const {
+	const Ref<CScriptNativeClass> &get_native() const {
 		return native;
 	}
 	const String &get_script_class_name() const {
@@ -180,12 +180,12 @@ public:
 	bool is_tool() const {
 		return tool;
 	}
-	Ref<GDScript> get_base() const;
+	Ref<CScript> get_base() const;
 
 	const Map<StringName, MemberInfo> &debug_get_member_indices() const {
 		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;
 
 	Variant _new(const Variant **p_args, int p_argcount, Variant::CallError &r_error);
@@ -241,27 +241,27 @@ public:
 	}
 #endif
 
-	GDScript();
-	~GDScript();
+	CScript();
+	~CScript();
 };
 
-class GDScriptInstance : public ScriptInstance {
-	friend class GDScript;
-	friend class GDScriptFunction;
-	friend class GDScriptFunctions;
-	friend class GDScriptCompiler;
+class CScriptInstance : public ScriptInstance {
+	friend class CScript;
+	friend class CScriptFunction;
+	friend class CScriptFunctions;
+	friend class CScriptCompiler;
 
 	Object *owner;
-	Ref<GDScript> script;
+	Ref<CScript> script;
 #ifdef DEBUG_ENABLED
 	Map<StringName, int> member_indices_cache; //used only for hot script reloading
 #endif
 	Vector<Variant> members;
 	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:
 	virtual Object *get_owner() {
@@ -295,12 +295,12 @@ public:
 	virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const;
 	virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const;
 
-	GDScriptInstance();
-	~GDScriptInstance();
+	CScriptInstance();
+	~CScriptInstance();
 };
 
 #ifdef DEBUG_ENABLED
-struct GDScriptWarning {
+struct CScriptWarning {
 	enum Code {
 		UNASSIGNED_VARIABLE, // Variable used but never assigned
 		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 Code get_code_from_name(const String &p_name);
 
-	GDScriptWarning() :
+	CScriptWarning() :
 			code(WARNING_MAX),
 			line(-1) {}
 };
 #endif // DEBUG_ENABLED
 
-class GDScriptLanguage : public ScriptLanguage {
-	friend class GDScriptFunctionState;
+class CScriptLanguage : public ScriptLanguage {
+	friend class CScriptFunctionState;
 
-	static GDScriptLanguage *singleton;
+	static CScriptLanguage *singleton;
 
 	Variant *_global_array;
 	Vector<Variant> global_array;
@@ -358,8 +358,8 @@ class GDScriptLanguage : public ScriptLanguage {
 
 	struct CallLevel {
 		Variant *stack;
-		GDScriptFunction *function;
-		GDScriptInstance *instance;
+		CScriptFunction *function;
+		CScriptInstance *instance;
 		int *ip;
 		int *line;
 	};
@@ -373,16 +373,16 @@ class GDScriptLanguage : public ScriptLanguage {
 
 	void _add_global(const StringName &p_name, const Variant &p_value);
 
-	friend class GDScriptInstance;
+	friend class CScriptInstance;
 
 	Mutex lock;
 
-	friend class GDScript;
+	friend class CScript;
 
-	SelfList<GDScript>::List script_list;
-	friend class GDScriptFunction;
+	SelfList<CScript>::List script_list;
+	friend class CScriptFunction;
 
-	SelfList<GDScriptFunction>::List function_list;
+	SelfList<CScriptFunction>::List function_list;
 	bool profiling;
 	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_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()) {
 			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, 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;
 
@@ -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;
 
 	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();
-	~GDScriptLanguage();
+	CScriptLanguage();
+	~CScriptLanguage();
 };
 
-class ResourceFormatLoaderGDScript : public ResourceFormatLoader {
+class ResourceFormatLoaderCScript : public ResourceFormatLoader {
 public:
 	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;
@@ -557,11 +557,11 @@ public:
 	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:
 	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 bool recognize(const RES &p_resource) const;
 };
 
-#endif // GDSCRIPT_H
+#endif // CSCRIPT_H
diff --git a/modules/cscript/cscript_compiler.cpp b/modules/cscript/cscript_compiler.cpp
index 7312e566e..50835f35d 100644
--- a/modules/cscript/cscript_compiler.cpp
+++ b/modules/cscript/cscript_compiler.cpp
@@ -32,7 +32,7 @@
 
 #include "cscript.h"
 
-bool GDScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
+bool CScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringName &p_name) {
 	if (codegen.function_node && codegen.function_node->_static) {
 		return false;
 	}
@@ -44,9 +44,9 @@ bool GDScriptCompiler::_is_class_member_property(CodeGen &codegen, const StringN
 	return _is_class_member_property(codegen.script, p_name);
 }
 
-bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringName &p_name) {
-	GDScript *scr = owner;
-	GDScriptNativeClass *nc = nullptr;
+bool CScriptCompiler::_is_class_member_property(CScript *owner, const StringName &p_name) {
+	CScript *scr = owner;
+	CScriptNativeClass *nc = nullptr;
 	while (scr) {
 		if (scr->native.is_valid()) {
 			nc = scr->native.ptr();
@@ -59,7 +59,7 @@ bool GDScriptCompiler::_is_class_member_property(GDScript *owner, const StringNa
 	return ClassDB::has_property(nc->get_name(), p_name);
 }
 
-void GDScriptCompiler::_set_error(const String &p_error, const GDScriptParser::Node *p_node) {
+void CScriptCompiler::_set_error(const String &p_error, const CScriptParser::Node *p_node) {
 	if (error != "") {
 		return;
 	}
@@ -74,7 +74,7 @@ void GDScriptCompiler::_set_error(const String &p_error, const GDScriptParser::N
 	}
 }
 
-bool GDScriptCompiler::_create_unary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level) {
+bool CScriptCompiler::_create_unary_operator(CodeGen &codegen, const CScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level) {
 	ERR_FAIL_COND_V(on->arguments.size() != 1, false);
 
 	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level);
@@ -82,22 +82,22 @@ bool GDScriptCompiler::_create_unary_operator(CodeGen &codegen, const GDScriptPa
 		return false;
 	}
 
-	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(CScriptFunction::OPCODE_OPERATOR); // perform operator
 	codegen.opcodes.push_back(op); //which operator
 	codegen.opcodes.push_back(src_address_a); // argument 1
 	codegen.opcodes.push_back(src_address_a); // argument 2 (repeated)
-	//codegen.opcodes.push_back(GDScriptFunction::ADDR_TYPE_NIL); // argument 2 (unary only takes one parameter)
+	//codegen.opcodes.push_back(CScriptFunction::ADDR_TYPE_NIL); // argument 2 (unary only takes one parameter)
 	return true;
 }
 
-bool GDScriptCompiler::_create_binary_operator(CodeGen &codegen, const GDScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer, int p_index_addr) {
+bool CScriptCompiler::_create_binary_operator(CodeGen &codegen, const CScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level, bool p_initializer, int p_index_addr) {
 	ERR_FAIL_COND_V(on->arguments.size() != 2, false);
 
 	int src_address_a = _parse_expression(codegen, on->arguments[0], p_stack_level, false, p_initializer, p_index_addr);
 	if (src_address_a < 0) {
 		return false;
 	}
-	if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+	if (src_address_a & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 		p_stack_level++; //uses stack for return, increase stack
 	}
 
@@ -106,70 +106,70 @@ bool GDScriptCompiler::_create_binary_operator(CodeGen &codegen, const GDScriptP
 		return false;
 	}
 
-	codegen.opcodes.push_back(GDScriptFunction::OPCODE_OPERATOR); // perform operator
+	codegen.opcodes.push_back(CScriptFunction::OPCODE_OPERATOR); // perform operator
 	codegen.opcodes.push_back(op); //which operator
 	codegen.opcodes.push_back(src_address_a); // argument 1
 	codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
 	return true;
 }
 
-GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::DataType &p_datatype, GDScript *p_owner) const {
+CScriptDataType CScriptCompiler::_gdtype_from_datatype(const CScriptParser::DataType &p_datatype, CScript *p_owner) const {
 	if (!p_datatype.has_type) {
-		return GDScriptDataType();
+		return CScriptDataType();
 	}
 
-	GDScriptDataType result;
+	CScriptDataType result;
 	result.has_type = true;
 
 	switch (p_datatype.kind) {
-		case GDScriptParser::DataType::BUILTIN: {
-			result.kind = GDScriptDataType::BUILTIN;
+		case CScriptParser::DataType::BUILTIN: {
+			result.kind = CScriptDataType::BUILTIN;
 			result.builtin_type = p_datatype.builtin_type;
 		} break;
-		case GDScriptParser::DataType::NATIVE: {
-			result.kind = GDScriptDataType::NATIVE;
+		case CScriptParser::DataType::NATIVE: {
+			result.kind = CScriptDataType::NATIVE;
 			result.native_type = p_datatype.native_type;
 		} break;
-		case GDScriptParser::DataType::SCRIPT: {
-			result.kind = GDScriptDataType::SCRIPT;
+		case CScriptParser::DataType::SCRIPT: {
+			result.kind = CScriptDataType::SCRIPT;
 			result.script_type_ref = Ref<Script>(p_datatype.script_type);
 			result.script_type = result.script_type_ref.ptr();
 			result.native_type = result.script_type->get_instance_base_type();
 		} break;
-		case GDScriptParser::DataType::GDSCRIPT: {
-			result.kind = GDScriptDataType::GDSCRIPT;
+		case CScriptParser::DataType::CSCRIPT: {
+			result.kind = CScriptDataType::CSCRIPT;
 			result.script_type_ref = Ref<Script>(p_datatype.script_type);
 			result.script_type = result.script_type_ref.ptr();
 			result.native_type = result.script_type->get_instance_base_type();
 		} break;
-		case GDScriptParser::DataType::CLASS: {
+		case CScriptParser::DataType::CLASS: {
 			// Locate class by constructing the path to it and following that path
-			GDScriptParser::ClassNode *class_type = p_datatype.class_type;
+			CScriptParser::ClassNode *class_type = p_datatype.class_type;
 			List<StringName> names;
 			while (class_type->owner) {
 				names.push_back(class_type->name);
 				class_type = class_type->owner;
 			}
 
-			Ref<GDScript> script = Ref<GDScript>(main_script);
+			Ref<CScript> script = Ref<CScript>(main_script);
 			while (names.back()) {
 				if (!script->subclasses.has(names.back()->get())) {
 					ERR_PRINT("Parser bug: Cannot locate datatype class.");
 					result.has_type = false;
-					return GDScriptDataType();
+					return CScriptDataType();
 				}
 				script = script->subclasses[names.back()->get()];
 				names.pop_back();
 			}
 
-			result.kind = GDScriptDataType::GDSCRIPT;
+			result.kind = CScriptDataType::CSCRIPT;
 			result.script_type_ref = Ref<Script>(script);
 			result.script_type = result.script_type_ref.ptr();
 			result.native_type = script->get_instance_base_type();
 		} break;
 		default: {
 			ERR_PRINT("Parser bug: converting unresolved type.");
-			return GDScriptDataType();
+			return CScriptDataType();
 		}
 	}
 
@@ -182,42 +182,42 @@ GDScriptDataType GDScriptCompiler::_gdtype_from_datatype(const GDScriptParser::D
 	return result;
 }
 
-int GDScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr) {
+int CScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const CScriptParser::OperatorNode *p_expression, int p_stack_level, int p_index_addr) {
 	Variant::Operator var_op = Variant::OP_MAX;
 
 	switch (p_expression->op) {
-		case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
+		case CScriptParser::OperatorNode::OP_ASSIGN_ADD:
 			var_op = Variant::OP_ADD;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_SUB:
+		case CScriptParser::OperatorNode::OP_ASSIGN_SUB:
 			var_op = Variant::OP_SUBTRACT;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_MUL:
+		case CScriptParser::OperatorNode::OP_ASSIGN_MUL:
 			var_op = Variant::OP_MULTIPLY;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_DIV:
+		case CScriptParser::OperatorNode::OP_ASSIGN_DIV:
 			var_op = Variant::OP_DIVIDE;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_MOD:
+		case CScriptParser::OperatorNode::OP_ASSIGN_MOD:
 			var_op = Variant::OP_MODULE;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+		case CScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
 			var_op = Variant::OP_SHIFT_LEFT;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+		case CScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
 			var_op = Variant::OP_SHIFT_RIGHT;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
+		case CScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
 			var_op = Variant::OP_BIT_AND;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
+		case CScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
 			var_op = Variant::OP_BIT_OR;
 			break;
-		case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
+		case CScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
 			var_op = Variant::OP_BIT_XOR;
 			break;
-		case GDScriptParser::OperatorNode::OP_INIT_ASSIGN:
-		case GDScriptParser::OperatorNode::OP_ASSIGN: {
+		case CScriptParser::OperatorNode::OP_INIT_ASSIGN:
+		case CScriptParser::OperatorNode::OP_ASSIGN: {
 			//none
 		} break;
 		default: {
@@ -225,7 +225,7 @@ int GDScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDS
 		}
 	}
 
-	bool initializer = p_expression->op == GDScriptParser::OperatorNode::OP_INIT_ASSIGN;
+	bool initializer = p_expression->op == CScriptParser::OperatorNode::OP_INIT_ASSIGN;
 
 	if (var_op == Variant::OP_MAX) {
 		return _parse_expression(codegen, p_expression->arguments[1], p_stack_level, false, initializer);
@@ -235,38 +235,38 @@ int GDScriptCompiler::_parse_assign_right_expression(CodeGen &codegen, const GDS
 		return -1;
 	}
 
-	int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+	int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 	codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 	codegen.alloc_stack(p_stack_level);
 	return dst_addr;
 }
 
-int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::Node *p_expression, int p_stack_level, bool p_root, bool p_initializer, int p_index_addr) {
+int CScriptCompiler::_parse_expression(CodeGen &codegen, const CScriptParser::Node *p_expression, int p_stack_level, bool p_root, bool p_initializer, int p_index_addr) {
 	switch (p_expression->type) {
 		//should parse variable declaration and adjust stack accordingly...
-		case GDScriptParser::Node::TYPE_IDENTIFIER: {
+		case CScriptParser::Node::TYPE_IDENTIFIER: {
 			//return identifier
 			//wait, identifier could be a local variable or something else... careful here, must reference properly
 			//as stack may be more interesting to work with
 
 			//This could be made much simpler by just indexing "self", but done this way (with custom self-addressing modes) increases performance a lot.
 
-			const GDScriptParser::IdentifierNode *in = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
+			const CScriptParser::IdentifierNode *in = static_cast<const CScriptParser::IdentifierNode *>(p_expression);
 
 			StringName identifier = in->name;
 
 			// TRY STACK!
 			if (!p_initializer && codegen.stack_identifiers.has(identifier)) {
 				int pos = codegen.stack_identifiers[identifier];
-				return pos | (GDScriptFunction::ADDR_TYPE_STACK_VARIABLE << GDScriptFunction::ADDR_BITS);
+				return pos | (CScriptFunction::ADDR_TYPE_STACK_VARIABLE << CScriptFunction::ADDR_BITS);
 			}
 
 			// TRY CLASS MEMBER
 			if (_is_class_member_property(codegen, identifier)) {
 				//get property
-				codegen.opcodes.push_back(GDScriptFunction::OPCODE_GET_MEMBER); // perform operator
+				codegen.opcodes.push_back(CScriptFunction::OPCODE_GET_MEMBER); // perform operator
 				codegen.opcodes.push_back(codegen.get_name_map_pos(identifier)); // argument 2 (unary only takes one parameter)
-				int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+				int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 				codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 				codegen.alloc_stack(p_stack_level);
 				return dst_addr;
@@ -278,21 +278,21 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				//static function
 				if (codegen.script->member_indices.has(identifier)) {
 					int idx = codegen.script->member_indices[identifier].index;
-					return idx | (GDScriptFunction::ADDR_TYPE_MEMBER << GDScriptFunction::ADDR_BITS); //argument (stack root)
+					return idx | (CScriptFunction::ADDR_TYPE_MEMBER << CScriptFunction::ADDR_BITS); //argument (stack root)
 				}
 			}
 
 			//TRY CLASS CONSTANTS
 
-			GDScript *owner = codegen.script;
+			CScript *owner = codegen.script;
 			while (owner) {
-				GDScript *scr = owner;
-				GDScriptNativeClass *nc = nullptr;
+				CScript *scr = owner;
+				CScriptNativeClass *nc = nullptr;
 				while (scr) {
 					if (scr->constants.has(identifier)) {
 						//int idx=scr->constants[identifier];
 						int idx = codegen.get_name_map_pos(identifier);
-						return idx | (GDScriptFunction::ADDR_TYPE_CLASS_CONSTANT << GDScriptFunction::ADDR_BITS); //argument (stack root)
+						return idx | (CScriptFunction::ADDR_TYPE_CLASS_CONSTANT << CScriptFunction::ADDR_BITS); //argument (stack root)
 					}
 					if (scr->native.is_valid()) {
 						nc = scr->native.ptr();
@@ -317,22 +317,22 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							idx = codegen.constant_map[key];
 						}
 
-						return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //make it a local constant (faster access)
+						return idx | (CScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << CScriptFunction::ADDR_BITS); //make it a local constant (faster access)
 					}
 				}
 
 				owner = owner->_owner;
 			}
 
-			if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
-				int idx = GDScriptLanguage::get_singleton()->get_global_map()[identifier];
-				return idx | (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+			if (CScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
+				int idx = CScriptLanguage::get_singleton()->get_global_map()[identifier];
+				return idx | (CScriptFunction::ADDR_TYPE_GLOBAL << CScriptFunction::ADDR_BITS); //argument (stack root)
 			}
 
 			/* TRY GLOBAL CLASSES */
 
 			if (ScriptServer::is_global_class(identifier)) {
-				const GDScriptParser::ClassNode *class_node = codegen.class_node;
+				const CScriptParser::ClassNode *class_node = codegen.class_node;
 				while (class_node->owner) {
 					class_node = class_node->owner;
 				}
@@ -359,17 +359,17 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					idx = codegen.constant_map[key];
 				}
 
-				return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //make it a local constant (faster access)
+				return idx | (CScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << CScriptFunction::ADDR_BITS); //make it a local constant (faster access)
 			}
 
 #ifdef TOOLS_ENABLED
-			if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
+			if (CScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
 				int idx = codegen.named_globals.find(identifier);
 				if (idx == -1) {
 					idx = codegen.named_globals.size();
 					codegen.named_globals.push_back(identifier);
 				}
-				return idx | (GDScriptFunction::ADDR_TYPE_NAMED_GLOBAL << GDScriptFunction::ADDR_BITS);
+				return idx | (CScriptFunction::ADDR_TYPE_NAMED_GLOBAL << CScriptFunction::ADDR_BITS);
 			}
 #endif
 
@@ -380,9 +380,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 			return -1;
 
 		} break;
-		case GDScriptParser::Node::TYPE_CONSTANT: {
+		case CScriptParser::Node::TYPE_CONSTANT: {
 			//return constant
-			const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(p_expression);
+			const CScriptParser::ConstantNode *cn = static_cast<const CScriptParser::ConstantNode *>(p_expression);
 
 			int idx;
 
@@ -394,19 +394,19 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				idx = codegen.constant_map[cn->value];
 			}
 
-			return idx | (GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS); //argument (stack root)
+			return idx | (CScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << CScriptFunction::ADDR_BITS); //argument (stack root)
 
 		} break;
-		case GDScriptParser::Node::TYPE_SELF: {
+		case CScriptParser::Node::TYPE_SELF: {
 			//return constant
 			if (codegen.function_node && codegen.function_node->_static) {
 				_set_error("'self' not present in static function!", p_expression);
 				return -1;
 			}
-			return (GDScriptFunction::ADDR_TYPE_SELF << GDScriptFunction::ADDR_BITS);
+			return (CScriptFunction::ADDR_TYPE_SELF << CScriptFunction::ADDR_BITS);
 		} break;
-		case GDScriptParser::Node::TYPE_ARRAY: {
-			const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
+		case CScriptParser::Node::TYPE_ARRAY: {
+			const CScriptParser::ArrayNode *an = static_cast<const CScriptParser::ArrayNode *>(p_expression);
 			Vector<int> values;
 
 			int slevel = p_stack_level;
@@ -416,7 +416,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				if (ret < 0) {
 					return ret;
 				}
-				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+				if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
@@ -424,20 +424,20 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				values.push_back(ret);
 			}
 
-			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_ARRAY);
+			codegen.opcodes.push_back(CScriptFunction::OPCODE_CONSTRUCT_ARRAY);
 			codegen.opcodes.push_back(values.size());
 			for (int i = 0; i < values.size(); i++) {
 				codegen.opcodes.push_back(values[i]);
 			}
 
-			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
 
 		} break;
-		case GDScriptParser::Node::TYPE_DICTIONARY: {
-			const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
+		case CScriptParser::Node::TYPE_DICTIONARY: {
+			const CScriptParser::DictionaryNode *dn = static_cast<const CScriptParser::DictionaryNode *>(p_expression);
 			Vector<int> values;
 
 			int slevel = p_stack_level;
@@ -447,7 +447,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				if (ret < 0) {
 					return ret;
 				}
-				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+				if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
@@ -458,7 +458,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				if (ret < 0) {
 					return ret;
 				}
-				if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+				if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 					slevel++;
 					codegen.alloc_stack(slevel);
 				}
@@ -466,57 +466,57 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				values.push_back(ret);
 			}
 
-			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT_DICTIONARY);
+			codegen.opcodes.push_back(CScriptFunction::OPCODE_CONSTRUCT_DICTIONARY);
 			codegen.opcodes.push_back(dn->elements.size());
 			for (int i = 0; i < values.size(); i++) {
 				codegen.opcodes.push_back(values[i]);
 			}
 
-			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
 
 		} break;
-		case GDScriptParser::Node::TYPE_CAST: {
-			const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
+		case CScriptParser::Node::TYPE_CAST: {
+			const CScriptParser::CastNode *cn = static_cast<const CScriptParser::CastNode *>(p_expression);
 
 			int slevel = p_stack_level;
 			int src_addr = _parse_expression(codegen, cn->source_node, slevel);
 			if (src_addr < 0) {
 				return src_addr;
 			}
-			if (src_addr & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+			if (src_addr & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 				slevel++;
 				codegen.alloc_stack(slevel);
 			}
 
-			GDScriptDataType cast_type = _gdtype_from_datatype(cn->cast_type);
+			CScriptDataType cast_type = _gdtype_from_datatype(cn->cast_type);
 
 			switch (cast_type.kind) {
-				case GDScriptDataType::BUILTIN: {
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_BUILTIN);
+				case CScriptDataType::BUILTIN: {
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_CAST_TO_BUILTIN);
 					codegen.opcodes.push_back(cast_type.builtin_type);
 				} break;
-				case GDScriptDataType::NATIVE: {
+				case CScriptDataType::NATIVE: {
 					int class_idx;
-					if (GDScriptLanguage::get_singleton()->get_global_map().has(cast_type.native_type)) {
-						class_idx = GDScriptLanguage::get_singleton()->get_global_map()[cast_type.native_type];
-						class_idx |= (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+					if (CScriptLanguage::get_singleton()->get_global_map().has(cast_type.native_type)) {
+						class_idx = CScriptLanguage::get_singleton()->get_global_map()[cast_type.native_type];
+						class_idx |= (CScriptFunction::ADDR_TYPE_GLOBAL << CScriptFunction::ADDR_BITS); //argument (stack root)
 					} else {
 						_set_error("Invalid native class type '" + String(cast_type.native_type) + "'.", cn);
 						return -1;
 					}
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_NATIVE); // perform operator
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_CAST_TO_NATIVE); // perform operator
 					codegen.opcodes.push_back(class_idx); // variable type
 				} break;
-				case GDScriptDataType::SCRIPT:
-				case GDScriptDataType::GDSCRIPT: {
+				case CScriptDataType::SCRIPT:
+				case CScriptDataType::CSCRIPT: {
 					Variant script = cast_type.script_type;
 					int idx = codegen.get_constant_pos(script);
-					idx |= GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS; //make it a local constant (faster access)
+					idx |= CScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << CScriptFunction::ADDR_BITS; //make it a local constant (faster access)
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CAST_TO_SCRIPT); // perform operator
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_CAST_TO_SCRIPT); // perform operator
 					codegen.opcodes.push_back(idx); // variable type
 				} break;
 				default: {
@@ -526,22 +526,22 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 			}
 
 			codegen.opcodes.push_back(src_addr); // source address
-			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
 
 		} break;
-		case GDScriptParser::Node::TYPE_OPERATOR: {
+		case CScriptParser::Node::TYPE_OPERATOR: {
 			//hell breaks loose
 
-			const GDScriptParser::OperatorNode *on = static_cast<const GDScriptParser::OperatorNode *>(p_expression);
+			const CScriptParser::OperatorNode *on = static_cast<const CScriptParser::OperatorNode *>(p_expression);
 			switch (on->op) {
 				//call/constructor operator
-				case GDScriptParser::OperatorNode::OP_PARENT_CALL: {
+				case CScriptParser::OperatorNode::OP_PARENT_CALL: {
 					ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
 
-					const GDScriptParser::IdentifierNode *in = (const GDScriptParser::IdentifierNode *)on->arguments[0];
+					const CScriptParser::IdentifierNode *in = (const CScriptParser::IdentifierNode *)on->arguments[0];
 
 					Vector<int> arguments;
 					int slevel = p_stack_level;
@@ -550,7 +550,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						if (ret < 0) {
 							return ret;
 						}
-						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+						if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -558,7 +558,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					}
 
 					//push call bytecode
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_SELF_BASE); // basic type constructor
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_CALL_SELF_BASE); // basic type constructor
 
 					codegen.opcodes.push_back(codegen.get_name_map_pos(in->name)); //instance
 					codegen.opcodes.push_back(arguments.size()); //argument count
@@ -568,12 +568,12 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					}
 
 				} break;
-				case GDScriptParser::OperatorNode::OP_CALL: {
-					if (on->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
+				case CScriptParser::OperatorNode::OP_CALL: {
+					if (on->arguments[0]->type == CScriptParser::Node::TYPE_TYPE) {
 						//construct a basic type
 						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
 
-						const GDScriptParser::TypeNode *tn = (const GDScriptParser::TypeNode *)on->arguments[0];
+						const CScriptParser::TypeNode *tn = (const CScriptParser::TypeNode *)on->arguments[0];
 						int vtype = tn->vtype;
 
 						Vector<int> arguments;
@@ -583,7 +583,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							if (ret < 0) {
 								return ret;
 							}
-							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+							if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
@@ -591,7 +591,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 
 						//push call bytecode
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_CONSTRUCT); // basic type constructor
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_CONSTRUCT); // basic type constructor
 						codegen.opcodes.push_back(vtype); //instance
 						codegen.opcodes.push_back(arguments.size()); //argument count
 						codegen.alloc_call(arguments.size());
@@ -599,7 +599,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							codegen.opcodes.push_back(arguments[i]); //arguments
 						}
 
-					} else if (on->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+					} else if (on->arguments[0]->type == CScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
 						//built in function
 
 						ERR_FAIL_COND_V(on->arguments.size() < 1, -1);
@@ -612,7 +612,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 								return ret;
 							}
 
-							if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+							if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
@@ -620,8 +620,8 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							arguments.push_back(ret);
 						}
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_BUILT_IN);
-						codegen.opcodes.push_back(static_cast<const GDScriptParser::BuiltInFunctionNode *>(on->arguments[0])->function);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_CALL_BUILT_IN);
+						codegen.opcodes.push_back(static_cast<const CScriptParser::BuiltInFunctionNode *>(on->arguments[0])->function);
 						codegen.opcodes.push_back(on->arguments.size() - 1);
 						codegen.alloc_call(on->arguments.size() - 1);
 						for (int i = 0; i < arguments.size(); i++) {
@@ -632,9 +632,9 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						//regular function
 						ERR_FAIL_COND_V(on->arguments.size() < 2, -1);
 
-						const GDScriptParser::Node *instance = on->arguments[0];
+						const CScriptParser::Node *instance = on->arguments[0];
 
-						if (instance->type == GDScriptParser::Node::TYPE_SELF) {
+						if (instance->type == CScriptParser::Node::TYPE_SELF) {
 							//room for optimization
 						}
 
@@ -644,15 +644,15 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						for (int i = 0; i < on->arguments.size(); i++) {
 							int ret;
 
-							if (i == 0 && on->arguments[i]->type == GDScriptParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) {
+							if (i == 0 && on->arguments[i]->type == CScriptParser::Node::TYPE_SELF && codegen.function_node && codegen.function_node->_static) {
 								//static call to self
-								ret = (GDScriptFunction::ADDR_TYPE_CLASS << GDScriptFunction::ADDR_BITS);
+								ret = (CScriptFunction::ADDR_TYPE_CLASS << CScriptFunction::ADDR_BITS);
 							} else if (i == 1) {
-								if (on->arguments[i]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+								if (on->arguments[i]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 									_set_error("Attempt to call a non-identifier.", on);
 									return -1;
 								}
-								GDScriptParser::IdentifierNode *id = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[i]);
+								CScriptParser::IdentifierNode *id = static_cast<CScriptParser::IdentifierNode *>(on->arguments[i]);
 								ret = codegen.get_name_map_pos(id->name);
 
 							} else {
@@ -660,7 +660,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 								if (ret < 0) {
 									return ret;
 								}
-								if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+								if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 									slevel++;
 									codegen.alloc_stack(slevel);
 								}
@@ -668,7 +668,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							arguments.push_back(ret);
 						}
 
-						codegen.opcodes.push_back(p_root ? GDScriptFunction::OPCODE_CALL : GDScriptFunction::OPCODE_CALL_RETURN); // perform operator
+						codegen.opcodes.push_back(p_root ? CScriptFunction::OPCODE_CALL : CScriptFunction::OPCODE_CALL_RETURN); // perform operator
 						codegen.opcodes.push_back(on->arguments.size() - 2);
 						codegen.alloc_call(on->arguments.size() - 2);
 						for (int i = 0; i < arguments.size(); i++) {
@@ -676,7 +676,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_YIELD: {
+				case CScriptParser::OperatorNode::OP_YIELD: {
 					ERR_FAIL_COND_V(on->arguments.size() && on->arguments.size() != 2, -1);
 
 					Vector<int> arguments;
@@ -686,7 +686,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						if (ret < 0) {
 							return ret;
 						}
-						if ((ret >> GDScriptFunction::ADDR_BITS & GDScriptFunction::ADDR_TYPE_STACK) == GDScriptFunction::ADDR_TYPE_STACK) {
+						if ((ret >> CScriptFunction::ADDR_BITS & CScriptFunction::ADDR_TYPE_STACK) == CScriptFunction::ADDR_TYPE_STACK) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -694,22 +694,22 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					}
 
 					//push call bytecode
-					codegen.opcodes.push_back(arguments.size() == 0 ? GDScriptFunction::OPCODE_YIELD : GDScriptFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
+					codegen.opcodes.push_back(arguments.size() == 0 ? CScriptFunction::OPCODE_YIELD : CScriptFunction::OPCODE_YIELD_SIGNAL); // basic type constructor
 					for (int i = 0; i < arguments.size(); i++) {
 						codegen.opcodes.push_back(arguments[i]); //arguments
 					}
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_YIELD_RESUME);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_YIELD_RESUME);
 					//next will be where to place the result :)
 
 				} break;
 
 				//indexing operator
-				case GDScriptParser::OperatorNode::OP_INDEX:
-				case GDScriptParser::OperatorNode::OP_INDEX_NAMED: {
+				case CScriptParser::OperatorNode::OP_INDEX:
+				case CScriptParser::OperatorNode::OP_INDEX_NAMED: {
 					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
 
 					int slevel = p_stack_level;
-					bool named = (on->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED);
+					bool named = (on->op == CScriptParser::OperatorNode::OP_INDEX_NAMED);
 
 					int from = _parse_expression(codegen, on->arguments[0], slevel);
 					if (from < 0) {
@@ -720,13 +720,13 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					if (p_index_addr != 0) {
 						index = p_index_addr;
 					} else if (named) {
-						if (on->arguments[0]->type == GDScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
-							GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1]);
-							const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
+						if (on->arguments[0]->type == CScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+							CScriptParser::IdentifierNode *identifier = static_cast<CScriptParser::IdentifierNode *>(on->arguments[1]);
+							const Map<StringName, CScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(identifier->name);
 
 #ifdef DEBUG_ENABLED
 							if (MI && MI->get().getter == codegen.function_node->name) {
-								String n = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1])->name;
+								String n = static_cast<CScriptParser::IdentifierNode *>(on->arguments[1])->name;
 								_set_error("Must use '" + n + "' instead of 'self." + n + "' in getter.", on);
 								return -1;
 							}
@@ -734,22 +734,22 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 							if (MI && MI->get().getter == "") {
 								// Faster than indexing self (as if no self. had been used)
-								return (MI->get().index) | (GDScriptFunction::ADDR_TYPE_MEMBER << GDScriptFunction::ADDR_BITS);
+								return (MI->get().index) | (CScriptFunction::ADDR_TYPE_MEMBER << CScriptFunction::ADDR_BITS);
 							}
 						}
 
-						index = codegen.get_name_map_pos(static_cast<GDScriptParser::IdentifierNode *>(on->arguments[1])->name);
+						index = codegen.get_name_map_pos(static_cast<CScriptParser::IdentifierNode *>(on->arguments[1])->name);
 
 					} else {
-						if (on->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT && static_cast<const GDScriptParser::ConstantNode *>(on->arguments[1])->value.get_type() == Variant::STRING) {
+						if (on->arguments[1]->type == CScriptParser::Node::TYPE_CONSTANT && static_cast<const CScriptParser::ConstantNode *>(on->arguments[1])->value.get_type() == Variant::STRING) {
 							//also, somehow, named (speed up anyway)
-							StringName name = static_cast<const GDScriptParser::ConstantNode *>(on->arguments[1])->value;
+							StringName name = static_cast<const CScriptParser::ConstantNode *>(on->arguments[1])->value;
 							index = codegen.get_name_map_pos(name);
 							named = true;
 
 						} else {
 							//regular indexing
-							if (from & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+							if (from & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 								slevel++;
 								codegen.alloc_stack(slevel);
 							}
@@ -761,19 +761,19 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 					}
 
-					codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_GET_NAMED : GDScriptFunction::OPCODE_GET); // perform operator
+					codegen.opcodes.push_back(named ? CScriptFunction::OPCODE_GET_NAMED : CScriptFunction::OPCODE_GET); // perform operator
 					codegen.opcodes.push_back(from); // argument 1
 					codegen.opcodes.push_back(index); // argument 2 (unary only takes one parameter)
 
 				} break;
-				case GDScriptParser::OperatorNode::OP_AND: {
+				case CScriptParser::OperatorNode::OP_AND: {
 					// AND operator with early out on failure
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
 					if (res < 0) {
 						return res;
 					}
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
 					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
@@ -783,31 +783,31 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return res;
 					}
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
 					int jump_fail_pos2 = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TRUE);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 					codegen.opcodes.write[jump_fail_pos] = codegen.opcodes.size();
 					codegen.opcodes.write[jump_fail_pos2] = codegen.opcodes.size();
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_FALSE);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+					return p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS;
 
 				} break;
-				case GDScriptParser::OperatorNode::OP_OR: {
+				case CScriptParser::OperatorNode::OP_OR: {
 					// OR operator with early out on success
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
 					if (res < 0) {
 						return res;
 					}
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
 					int jump_success_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
@@ -817,32 +817,32 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return res;
 					}
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF);
 					codegen.opcodes.push_back(res);
 					int jump_success_pos2 = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_FALSE);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_FALSE);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 					codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 					codegen.opcodes.write[jump_success_pos] = codegen.opcodes.size();
 					codegen.opcodes.write[jump_success_pos2] = codegen.opcodes.size();
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TRUE);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_TRUE);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+					return p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS;
 
 				} break;
 				// ternary operators
-				case GDScriptParser::OperatorNode::OP_TERNARY_IF: {
+				case CScriptParser::OperatorNode::OP_TERNARY_IF: {
 					// x IF a ELSE y operator with early out on failure
 
 					int res = _parse_expression(codegen, on->arguments[0], p_stack_level);
 					if (res < 0) {
 						return res;
 					}
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF_NOT);
 					codegen.opcodes.push_back(res);
 					int jump_fail_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
@@ -853,10 +853,10 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 					}
 
 					codegen.alloc_stack(p_stack_level); //it will be used..
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 					codegen.opcodes.push_back(res);
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 					int jump_past_pos = codegen.opcodes.size();
 					codegen.opcodes.push_back(0);
 
@@ -866,150 +866,150 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return res;
 					}
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
-					codegen.opcodes.push_back(p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN);
+					codegen.opcodes.push_back(p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 					codegen.opcodes.push_back(res);
 
 					codegen.opcodes.write[jump_past_pos] = codegen.opcodes.size();
 
-					return p_stack_level | GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS;
+					return p_stack_level | CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS;
 
 				} break;
 				//unary operators
-				case GDScriptParser::OperatorNode::OP_NEG: {
+				case CScriptParser::OperatorNode::OP_NEG: {
 					if (!_create_unary_operator(codegen, on, Variant::OP_NEGATE, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_POS: {
+				case CScriptParser::OperatorNode::OP_POS: {
 					if (!_create_unary_operator(codegen, on, Variant::OP_POSITIVE, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_NOT: {
+				case CScriptParser::OperatorNode::OP_NOT: {
 					if (!_create_unary_operator(codegen, on, Variant::OP_NOT, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_BIT_INVERT: {
+				case CScriptParser::OperatorNode::OP_BIT_INVERT: {
 					if (!_create_unary_operator(codegen, on, Variant::OP_BIT_NEGATE, p_stack_level)) {
 						return -1;
 					}
 				} break;
 				//binary operators (in precedence order)
-				case GDScriptParser::OperatorNode::OP_IN: {
+				case CScriptParser::OperatorNode::OP_IN: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_IN, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_EQUAL: {
+				case CScriptParser::OperatorNode::OP_EQUAL: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_EQUAL, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_NOT_EQUAL: {
+				case CScriptParser::OperatorNode::OP_NOT_EQUAL: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_NOT_EQUAL, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_LESS: {
+				case CScriptParser::OperatorNode::OP_LESS: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_LESS, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_LESS_EQUAL: {
+				case CScriptParser::OperatorNode::OP_LESS_EQUAL: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_LESS_EQUAL, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_GREATER: {
+				case CScriptParser::OperatorNode::OP_GREATER: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_GREATER_EQUAL: {
+				case CScriptParser::OperatorNode::OP_GREATER_EQUAL: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_GREATER_EQUAL, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_ADD: {
+				case CScriptParser::OperatorNode::OP_ADD: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_ADD, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_SUB: {
+				case CScriptParser::OperatorNode::OP_SUB: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_SUBTRACT, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_MUL: {
+				case CScriptParser::OperatorNode::OP_MUL: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_MULTIPLY, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_DIV: {
+				case CScriptParser::OperatorNode::OP_DIV: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_DIVIDE, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_MOD: {
+				case CScriptParser::OperatorNode::OP_MOD: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_MODULE, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				//case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
-				//case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
-				case GDScriptParser::OperatorNode::OP_BIT_AND: {
+				//case CScriptParser::OperatorNode::OP_SHIFT_LEFT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_LEFT,p_stack_level)) return -1;} break;
+				//case CScriptParser::OperatorNode::OP_SHIFT_RIGHT: { if (!_create_binary_operator(codegen,on,Variant::OP_SHIFT_RIGHT,p_stack_level)) return -1;} break;
+				case CScriptParser::OperatorNode::OP_BIT_AND: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_AND, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_BIT_OR: {
+				case CScriptParser::OperatorNode::OP_BIT_OR: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_OR, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_BIT_XOR: {
+				case CScriptParser::OperatorNode::OP_BIT_XOR: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_BIT_XOR, p_stack_level)) {
 						return -1;
 					}
 				} break;
 				//shift
-				case GDScriptParser::OperatorNode::OP_SHIFT_LEFT: {
+				case CScriptParser::OperatorNode::OP_SHIFT_LEFT: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_LEFT, p_stack_level)) {
 						return -1;
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT: {
+				case CScriptParser::OperatorNode::OP_SHIFT_RIGHT: {
 					if (!_create_binary_operator(codegen, on, Variant::OP_SHIFT_RIGHT, p_stack_level)) {
 						return -1;
 					}
 				} break;
 				//assignment operators
-				case GDScriptParser::OperatorNode::OP_ASSIGN_ADD:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_SUB:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_MUL:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_DIV:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_MOD:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
-				case GDScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
-				case GDScriptParser::OperatorNode::OP_INIT_ASSIGN:
-				case GDScriptParser::OperatorNode::OP_ASSIGN: {
+				case CScriptParser::OperatorNode::OP_ASSIGN_ADD:
+				case CScriptParser::OperatorNode::OP_ASSIGN_SUB:
+				case CScriptParser::OperatorNode::OP_ASSIGN_MUL:
+				case CScriptParser::OperatorNode::OP_ASSIGN_DIV:
+				case CScriptParser::OperatorNode::OP_ASSIGN_MOD:
+				case CScriptParser::OperatorNode::OP_ASSIGN_SHIFT_LEFT:
+				case CScriptParser::OperatorNode::OP_ASSIGN_SHIFT_RIGHT:
+				case CScriptParser::OperatorNode::OP_ASSIGN_BIT_AND:
+				case CScriptParser::OperatorNode::OP_ASSIGN_BIT_OR:
+				case CScriptParser::OperatorNode::OP_ASSIGN_BIT_XOR:
+				case CScriptParser::OperatorNode::OP_INIT_ASSIGN:
+				case CScriptParser::OperatorNode::OP_ASSIGN: {
 					ERR_FAIL_COND_V(on->arguments.size() != 2, -1);
 
-					if (on->arguments[0]->type == GDScriptParser::Node::TYPE_OPERATOR && (static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX || static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED)) {
+					if (on->arguments[0]->type == CScriptParser::Node::TYPE_OPERATOR && (static_cast<CScriptParser::OperatorNode *>(on->arguments[0])->op == CScriptParser::OperatorNode::OP_INDEX || static_cast<CScriptParser::OperatorNode *>(on->arguments[0])->op == CScriptParser::OperatorNode::OP_INDEX_NAMED)) {
 						// SET (chained) MODE!
 #ifdef DEBUG_ENABLED
-						if (static_cast<GDScriptParser::OperatorNode *>(on->arguments[0])->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
-							const GDScriptParser::OperatorNode *inon = static_cast<GDScriptParser::OperatorNode *>(on->arguments[0]);
+						if (static_cast<CScriptParser::OperatorNode *>(on->arguments[0])->op == CScriptParser::OperatorNode::OP_INDEX_NAMED) {
+							const CScriptParser::OperatorNode *inon = static_cast<CScriptParser::OperatorNode *>(on->arguments[0]);
 
-							if (inon->arguments[0]->type == GDScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
-								const Map<StringName, GDScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<GDScriptParser::IdentifierNode *>(inon->arguments[1])->name);
+							if (inon->arguments[0]->type == CScriptParser::Node::TYPE_SELF && codegen.script && codegen.function_node && !codegen.function_node->_static) {
+								const Map<StringName, CScript::MemberInfo>::Element *MI = codegen.script->member_indices.find(static_cast<CScriptParser::IdentifierNode *>(inon->arguments[1])->name);
 								if (MI && MI->get().setter == codegen.function_node->name) {
-									String n = static_cast<GDScriptParser::IdentifierNode *>(inon->arguments[1])->name;
+									String n = static_cast<CScriptParser::IdentifierNode *>(inon->arguments[1])->name;
 									_set_error("Must use '" + n + "' instead of 'self." + n + "' in setter.", inon);
 									return -1;
 								}
@@ -1019,31 +1019,31 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 						int slevel = p_stack_level;
 
-						GDScriptParser::OperatorNode *op = static_cast<GDScriptParser::OperatorNode *>(on->arguments[0]);
+						CScriptParser::OperatorNode *op = static_cast<CScriptParser::OperatorNode *>(on->arguments[0]);
 
 						/* Find chain of sets */
 
 						StringName assign_property;
 
-						List<GDScriptParser::OperatorNode *> chain;
+						List<CScriptParser::OperatorNode *> chain;
 
 						{
 							//create get/set chain
-							GDScriptParser::OperatorNode *n = op;
+							CScriptParser::OperatorNode *n = op;
 							while (true) {
 								chain.push_back(n);
-								if (n->arguments[0]->type != GDScriptParser::Node::TYPE_OPERATOR) {
+								if (n->arguments[0]->type != CScriptParser::Node::TYPE_OPERATOR) {
 									//check for a built-in property
-									if (n->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
-										GDScriptParser::IdentifierNode *identifier = static_cast<GDScriptParser::IdentifierNode *>(n->arguments[0]);
+									if (n->arguments[0]->type == CScriptParser::Node::TYPE_IDENTIFIER) {
+										CScriptParser::IdentifierNode *identifier = static_cast<CScriptParser::IdentifierNode *>(n->arguments[0]);
 										if (_is_class_member_property(codegen, identifier->name)) {
 											assign_property = identifier->name;
 										}
 									}
 									break;
 								}
-								n = static_cast<GDScriptParser::OperatorNode *>(n->arguments[0]);
-								if (n->op != GDScriptParser::OperatorNode::OP_INDEX && n->op != GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
+								n = static_cast<CScriptParser::OperatorNode *>(n->arguments[0]);
+								if (n->op != CScriptParser::OperatorNode::OP_INDEX && n->op != CScriptParser::OperatorNode::OP_INDEX_NAMED) {
 									break;
 								}
 							}
@@ -1058,7 +1058,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						}
 						int retval = prev_pos;
 
-						if (retval & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+						if (retval & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -1071,28 +1071,28 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							// in Node2D
 							setchain.push_back(prev_pos);
 							setchain.push_back(codegen.get_name_map_pos(assign_property));
-							setchain.push_back(GDScriptFunction::OPCODE_SET_MEMBER);
+							setchain.push_back(CScriptFunction::OPCODE_SET_MEMBER);
 						}
 
-						for (List<GDScriptParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) {
+						for (List<CScriptParser::OperatorNode *>::Element *E = chain.back(); E; E = E->prev()) {
 							if (E == chain.front()) { //ignore first
 								break;
 							}
 
-							bool named = E->get()->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED;
+							bool named = E->get()->op == CScriptParser::OperatorNode::OP_INDEX_NAMED;
 							int key_idx;
 
 							if (named) {
-								key_idx = codegen.get_name_map_pos(static_cast<const GDScriptParser::IdentifierNode *>(E->get()->arguments[1])->name);
+								key_idx = codegen.get_name_map_pos(static_cast<const CScriptParser::IdentifierNode *>(E->get()->arguments[1])->name);
 								//printf("named key %x\n",key_idx);
 
 							} else {
-								if (prev_pos & (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS)) {
+								if (prev_pos & (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS)) {
 									slevel++;
 									codegen.alloc_stack(slevel);
 								}
 
-								GDScriptParser::Node *key = E->get()->arguments[1];
+								CScriptParser::Node *key = E->get()->arguments[1];
 								key_idx = _parse_expression(codegen, key, slevel);
 								//printf("expr key %x\n",key_idx);
 
@@ -1103,12 +1103,12 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 								return key_idx;
 							}
 
-							codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_GET_NAMED : GDScriptFunction::OPCODE_GET);
+							codegen.opcodes.push_back(named ? CScriptFunction::OPCODE_GET_NAMED : CScriptFunction::OPCODE_GET);
 							codegen.opcodes.push_back(prev_pos);
 							codegen.opcodes.push_back(key_idx);
 							slevel++;
 							codegen.alloc_stack(slevel);
-							int dst_pos = (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) | slevel;
+							int dst_pos = (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) | slevel;
 
 							codegen.opcodes.push_back(dst_pos);
 
@@ -1117,7 +1117,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							setchain.push_back(dst_pos);
 							setchain.push_back(key_idx);
 							setchain.push_back(prev_pos);
-							setchain.push_back(named ? GDScriptFunction::OPCODE_SET_NAMED : GDScriptFunction::OPCODE_SET);
+							setchain.push_back(named ? CScriptFunction::OPCODE_SET_NAMED : CScriptFunction::OPCODE_SET);
 
 							prev_pos = dst_pos;
 						}
@@ -1127,8 +1127,8 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						int set_index;
 						bool named = false;
 
-						if (op->op == GDScriptParser::OperatorNode::OP_INDEX_NAMED) {
-							set_index = codegen.get_name_map_pos(static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1])->name);
+						if (op->op == CScriptParser::OperatorNode::OP_INDEX_NAMED) {
+							set_index = codegen.get_name_map_pos(static_cast<const CScriptParser::IdentifierNode *>(op->arguments[1])->name);
 							named = true;
 						} else {
 							set_index = _parse_expression(codegen, op->arguments[1], slevel + 1);
@@ -1139,7 +1139,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							return set_index;
 						}
 
-						if (set_index & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+						if (set_index & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -1149,7 +1149,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							return set_value;
 						}
 
-						codegen.opcodes.push_back(named ? GDScriptFunction::OPCODE_SET_NAMED : GDScriptFunction::OPCODE_SET);
+						codegen.opcodes.push_back(named ? CScriptFunction::OPCODE_SET_NAMED : CScriptFunction::OPCODE_SET);
 						codegen.opcodes.push_back(prev_pos);
 						codegen.opcodes.push_back(set_index);
 						codegen.opcodes.push_back(set_value);
@@ -1160,7 +1160,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 
 						return retval;
 
-					} else if (on->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast<GDScriptParser::IdentifierNode *>(on->arguments[0])->name)) {
+					} else if (on->arguments[0]->type == CScriptParser::Node::TYPE_IDENTIFIER && _is_class_member_property(codegen, static_cast<CScriptParser::IdentifierNode *>(on->arguments[0])->name)) {
 						//assignment to member property
 
 						int slevel = p_stack_level;
@@ -1170,24 +1170,24 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							return -1;
 						}
 
-						StringName name = static_cast<GDScriptParser::IdentifierNode *>(on->arguments[0])->name;
+						StringName name = static_cast<CScriptParser::IdentifierNode *>(on->arguments[0])->name;
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_SET_MEMBER);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_SET_MEMBER);
 						codegen.opcodes.push_back(codegen.get_name_map_pos(name));
 						codegen.opcodes.push_back(src_address);
 
-						return GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
+						return CScriptFunction::ADDR_TYPE_NIL << CScriptFunction::ADDR_BITS;
 					} else {
 						//REGULAR ASSIGNMENT MODE!!
 
 						int slevel = p_stack_level;
 
-						int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == GDScriptParser::OperatorNode::OP_INIT_ASSIGN);
+						int dst_address_a = _parse_expression(codegen, on->arguments[0], slevel, false, on->op == CScriptParser::OperatorNode::OP_INIT_ASSIGN);
 						if (dst_address_a < 0) {
 							return -1;
 						}
 
-						if (dst_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+						if (dst_address_a & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 							slevel++;
 							codegen.alloc_stack(slevel);
 						}
@@ -1197,38 +1197,38 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 							return -1;
 						}
 
-						GDScriptDataType assign_type = _gdtype_from_datatype(on->arguments[0]->get_datatype());
+						CScriptDataType assign_type = _gdtype_from_datatype(on->arguments[0]->get_datatype());
 
 						if (assign_type.has_type && !on->datatype.has_type) {
 							// Typed assignment
 							switch (assign_type.kind) {
-								case GDScriptDataType::BUILTIN: {
-									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN); // perform operator
+								case CScriptDataType::BUILTIN: {
+									codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_TYPED_BUILTIN); // perform operator
 									codegen.opcodes.push_back(assign_type.builtin_type); // variable type
 									codegen.opcodes.push_back(dst_address_a); // argument 1
 									codegen.opcodes.push_back(src_address_b); // argument 2
 								} break;
-								case GDScriptDataType::NATIVE: {
+								case CScriptDataType::NATIVE: {
 									int class_idx;
-									if (GDScriptLanguage::get_singleton()->get_global_map().has(assign_type.native_type)) {
-										class_idx = GDScriptLanguage::get_singleton()->get_global_map()[assign_type.native_type];
-										class_idx |= (GDScriptFunction::ADDR_TYPE_GLOBAL << GDScriptFunction::ADDR_BITS); //argument (stack root)
+									if (CScriptLanguage::get_singleton()->get_global_map().has(assign_type.native_type)) {
+										class_idx = CScriptLanguage::get_singleton()->get_global_map()[assign_type.native_type];
+										class_idx |= (CScriptFunction::ADDR_TYPE_GLOBAL << CScriptFunction::ADDR_BITS); //argument (stack root)
 									} else {
 										_set_error("Invalid native class type '" + String(assign_type.native_type) + "'.", on->arguments[0]);
 										return -1;
 									}
-									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE); // perform operator
+									codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_TYPED_NATIVE); // perform operator
 									codegen.opcodes.push_back(class_idx); // variable type
 									codegen.opcodes.push_back(dst_address_a); // argument 1
 									codegen.opcodes.push_back(src_address_b); // argument 2
 								} break;
-								case GDScriptDataType::SCRIPT:
-								case GDScriptDataType::GDSCRIPT: {
+								case CScriptDataType::SCRIPT:
+								case CScriptDataType::CSCRIPT: {
 									Variant script = assign_type.script_type;
 									int idx = codegen.get_constant_pos(script);
-									idx |= GDScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << GDScriptFunction::ADDR_BITS; //make it a local constant (faster access)
+									idx |= CScriptFunction::ADDR_TYPE_LOCAL_CONSTANT << CScriptFunction::ADDR_BITS; //make it a local constant (faster access)
 
-									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT); // perform operator
+									codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN_TYPED_SCRIPT); // perform operator
 									codegen.opcodes.push_back(idx); // variable type
 									codegen.opcodes.push_back(dst_address_a); // argument 1
 									codegen.opcodes.push_back(src_address_b); // argument 2
@@ -1237,21 +1237,21 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 									ERR_PRINT("Compiler bug: unresolved assign.");
 
 									// Shouldn't get here, but fail-safe to a regular assignment
-									codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN); // perform operator
+									codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN); // perform operator
 									codegen.opcodes.push_back(dst_address_a); // argument 1
 									codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
 								}
 							}
 						} else {
 							// Either untyped assignment or already type-checked by the parser
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN); // perform operator
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN); // perform operator
 							codegen.opcodes.push_back(dst_address_a); // argument 1
 							codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
 						}
 						return dst_address_a; //if anything, returns whatever was assigned or correct stack position
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_IS: {
+				case CScriptParser::OperatorNode::OP_IS: {
 					ERR_FAIL_COND_V(on->arguments.size() != 2, false);
 
 					int slevel = p_stack_level;
@@ -1261,7 +1261,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return -1;
 					}
 
-					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+					if (src_address_a & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 						slevel++; //uses stack for return, increase stack
 					}
 
@@ -1270,14 +1270,14 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return -1;
 					}
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_EXTENDS_TEST); // perform operator
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_EXTENDS_TEST); // perform operator
 					codegen.opcodes.push_back(src_address_a); // argument 1
 					codegen.opcodes.push_back(src_address_b); // argument 2 (unary only takes one parameter)
 
 				} break;
-				case GDScriptParser::OperatorNode::OP_IS_BUILTIN: {
+				case CScriptParser::OperatorNode::OP_IS_BUILTIN: {
 					ERR_FAIL_COND_V(on->arguments.size() != 2, false);
-					ERR_FAIL_COND_V(on->arguments[1]->type != GDScriptParser::Node::TYPE_TYPE, false);
+					ERR_FAIL_COND_V(on->arguments[1]->type != CScriptParser::Node::TYPE_TYPE, false);
 
 					int slevel = p_stack_level;
 
@@ -1286,13 +1286,13 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 						return -1;
 					}
 
-					if (src_address_a & GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) {
+					if (src_address_a & CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) {
 						slevel++; //uses stack for return, increase stack
 					}
 
-					const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(on->arguments[1]);
+					const CScriptParser::TypeNode *tn = static_cast<const CScriptParser::TypeNode *>(on->arguments[1]);
 
-					codegen.opcodes.push_back(GDScriptFunction::OPCODE_IS_BUILTIN); // perform operator
+					codegen.opcodes.push_back(CScriptFunction::OPCODE_IS_BUILTIN); // perform operator
 					codegen.opcodes.push_back(src_address_a); // argument 1
 					codegen.opcodes.push_back((int)tn->vtype); // argument 2 (unary only takes one parameter)
 				} break;
@@ -1302,7 +1302,7 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 				} break;
 			}
 
-			int dst_addr = (p_stack_level) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+			int dst_addr = (p_stack_level) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 			codegen.opcodes.push_back(dst_addr); // append the stack level as destination address of the opcode
 			codegen.alloc_stack(p_stack_level);
 			return dst_addr;
@@ -1314,33 +1314,33 @@ int GDScriptCompiler::_parse_expression(CodeGen &codegen, const GDScriptParser::
 	}
 }
 
-Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::BlockNode *p_block, int p_stack_level, int p_break_addr, int p_continue_addr) {
+Error CScriptCompiler::_parse_block(CodeGen &codegen, const CScriptParser::BlockNode *p_block, int p_stack_level, int p_break_addr, int p_continue_addr) {
 	codegen.push_stack_identifiers();
 	int new_identifiers = 0;
 	codegen.current_line = p_block->line;
 
 	for (int i = 0; i < p_block->statements.size(); i++) {
-		const GDScriptParser::Node *s = p_block->statements[i];
+		const CScriptParser::Node *s = p_block->statements[i];
 
 		switch (s->type) {
-			case GDScriptParser::Node::TYPE_NEWLINE: {
+			case CScriptParser::Node::TYPE_NEWLINE: {
 #ifdef DEBUG_ENABLED
-				const GDScriptParser::NewLineNode *nl = static_cast<const GDScriptParser::NewLineNode *>(s);
-				codegen.opcodes.push_back(GDScriptFunction::OPCODE_LINE);
+				const CScriptParser::NewLineNode *nl = static_cast<const CScriptParser::NewLineNode *>(s);
+				codegen.opcodes.push_back(CScriptFunction::OPCODE_LINE);
 				codegen.opcodes.push_back(nl->line);
 				codegen.current_line = nl->line;
 #endif
 			} break;
-			case GDScriptParser::Node::TYPE_CONTROL_FLOW: {
+			case CScriptParser::Node::TYPE_CONTROL_FLOW: {
 				// try subblocks
 
-				const GDScriptParser::ControlFlowNode *cf = static_cast<const GDScriptParser::ControlFlowNode *>(s);
+				const CScriptParser::ControlFlowNode *cf = static_cast<const CScriptParser::ControlFlowNode *>(s);
 
 				switch (cf->cf_type) {
-					case GDScriptParser::ControlFlowNode::CF_MATCH: {
-						GDScriptParser::MatchNode *match = cf->match;
+					case CScriptParser::ControlFlowNode::CF_MATCH: {
+						CScriptParser::MatchNode *match = cf->match;
 
-						GDScriptParser::IdentifierNode *id = memnew(GDScriptParser::IdentifierNode);
+						CScriptParser::IdentifierNode *id = memnew(CScriptParser::IdentifierNode);
 						id->name = "#match_value";
 
 						// var #match_value
@@ -1349,8 +1349,8 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						codegen.alloc_stack(p_stack_level);
 						new_identifiers++;
 
-						GDScriptParser::OperatorNode *op = memnew(GDScriptParser::OperatorNode);
-						op->op = GDScriptParser::OperatorNode::OP_ASSIGN;
+						CScriptParser::OperatorNode *op = memnew(CScriptParser::OperatorNode);
+						op->op = CScriptParser::OperatorNode::OP_ASSIGN;
 						op->arguments.push_back(id);
 						op->arguments.push_back(match->val_to_match);
 
@@ -1362,14 +1362,14 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						}
 
 						// break address
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 						int break_addr = codegen.opcodes.size();
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(0); // break addr
 
 						for (int j = 0; j < match->compiled_pattern_branches.size(); j++) {
-							GDScriptParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j];
+							CScriptParser::MatchNode::CompiledPatternBranch branch = match->compiled_pattern_branches[j];
 
 							// jump over continue
 							// jump unconditionally
@@ -1382,11 +1382,11 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 								return ERR_PARSE_ERROR;
 							}
 
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF);
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF);
 							codegen.opcodes.push_back(ret2);
 							codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 							int continue_addr = codegen.opcodes.size();
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 							codegen.opcodes.push_back(0);
 
 							Error err = _parse_block(codegen, branch.body, p_stack_level, p_break_addr, continue_addr);
@@ -1396,7 +1396,7 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 								return ERR_PARSE_ERROR;
 							}
 
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 							codegen.opcodes.push_back(break_addr);
 
 							codegen.opcodes.write[continue_addr + 1] = codegen.opcodes.size();
@@ -1409,13 +1409,13 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 
 					} break;
 
-					case GDScriptParser::ControlFlowNode::CF_IF: {
+					case CScriptParser::ControlFlowNode::CF_IF: {
 						int ret2 = _parse_expression(codegen, cf->arguments[0], p_stack_level, false);
 						if (ret2 < 0) {
 							return ERR_PARSE_ERROR;
 						}
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF_NOT);
 						codegen.opcodes.push_back(ret2);
 						int else_addr = codegen.opcodes.size();
 						codegen.opcodes.push_back(0); //temporary
@@ -1426,12 +1426,12 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						}
 
 						if (cf->body_else) {
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 							int end_addr = codegen.opcodes.size();
 							codegen.opcodes.push_back(0);
 							codegen.opcodes.write[else_addr] = codegen.opcodes.size();
 
-							codegen.opcodes.push_back(GDScriptFunction::OPCODE_LINE);
+							codegen.opcodes.push_back(CScriptFunction::OPCODE_LINE);
 							codegen.opcodes.push_back(cf->body_else->line);
 							codegen.current_line = cf->body_else->line;
 
@@ -1447,16 +1447,16 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						}
 
 					} break;
-					case GDScriptParser::ControlFlowNode::CF_FOR: {
+					case CScriptParser::ControlFlowNode::CF_FOR: {
 						int slevel = p_stack_level;
 						int iter_stack_pos = slevel;
-						int iterator_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-						int counter_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
-						int container_pos = (slevel++) | (GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS);
+						int iterator_pos = (slevel++) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+						int counter_pos = (slevel++) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
+						int container_pos = (slevel++) | (CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS);
 						codegen.alloc_stack(slevel);
 
 						codegen.push_stack_identifiers();
-						codegen.add_stack_identifier(static_cast<const GDScriptParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
+						codegen.add_stack_identifier(static_cast<const CScriptParser::IdentifierNode *>(cf->arguments[0])->name, iter_stack_pos);
 
 						int ret2 = _parse_expression(codegen, cf->arguments[1], slevel, false);
 						if (ret2 < 0) {
@@ -1464,25 +1464,25 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						}
 
 						//assign container
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSIGN);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSIGN);
 						codegen.opcodes.push_back(container_pos);
 						codegen.opcodes.push_back(ret2);
 
 						//begin loop
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ITERATE_BEGIN);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_ITERATE_BEGIN);
 						codegen.opcodes.push_back(counter_pos);
 						codegen.opcodes.push_back(container_pos);
 						codegen.opcodes.push_back(codegen.opcodes.size() + 4);
 						codegen.opcodes.push_back(iterator_pos);
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP); //skip code for next
 						codegen.opcodes.push_back(codegen.opcodes.size() + 8);
 						//break loop
 						int break_pos = codegen.opcodes.size();
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP); //skip code for next
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP); //skip code for next
 						codegen.opcodes.push_back(0); //skip code for next
 						//next loop
 						int continue_pos = codegen.opcodes.size();
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_ITERATE);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_ITERATE);
 						codegen.opcodes.push_back(counter_pos);
 						codegen.opcodes.push_back(container_pos);
 						codegen.opcodes.push_back(break_pos);
@@ -1493,18 +1493,18 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							return err;
 						}
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_pos);
 						codegen.opcodes.write[break_pos + 1] = codegen.opcodes.size();
 
 						codegen.pop_stack_identifiers();
 
 					} break;
-					case GDScriptParser::ControlFlowNode::CF_WHILE: {
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+					case CScriptParser::ControlFlowNode::CF_WHILE: {
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(codegen.opcodes.size() + 3);
 						int break_addr = codegen.opcodes.size();
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(0);
 						int continue_addr = codegen.opcodes.size();
 
@@ -1512,39 +1512,39 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 						if (ret2 < 0) {
 							return ERR_PARSE_ERROR;
 						}
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_IF_NOT);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_IF_NOT);
 						codegen.opcodes.push_back(ret2);
 						codegen.opcodes.push_back(break_addr);
 						Error err = _parse_block(codegen, cf->body, p_stack_level, break_addr, continue_addr);
 						if (err) {
 							return err;
 						}
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(continue_addr);
 
 						codegen.opcodes.write[break_addr + 1] = codegen.opcodes.size();
 
 					} break;
-					case GDScriptParser::ControlFlowNode::CF_BREAK: {
+					case CScriptParser::ControlFlowNode::CF_BREAK: {
 						if (p_break_addr < 0) {
 							_set_error("'break'' not within loop", cf);
 							return ERR_COMPILATION_FAILED;
 						}
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(p_break_addr);
 
 					} break;
-					case GDScriptParser::ControlFlowNode::CF_CONTINUE: {
+					case CScriptParser::ControlFlowNode::CF_CONTINUE: {
 						if (p_continue_addr < 0) {
 							_set_error("'continue' not within loop", cf);
 							return ERR_COMPILATION_FAILED;
 						}
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP);
 						codegen.opcodes.push_back(p_continue_addr);
 
 					} break;
-					case GDScriptParser::ControlFlowNode::CF_RETURN: {
+					case CScriptParser::ControlFlowNode::CF_RETURN: {
 						int ret2;
 
 						if (cf->arguments.size()) {
@@ -1554,20 +1554,20 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 							}
 
 						} else {
-							ret2 = GDScriptFunction::ADDR_TYPE_NIL << GDScriptFunction::ADDR_BITS;
+							ret2 = CScriptFunction::ADDR_TYPE_NIL << CScriptFunction::ADDR_BITS;
 						}
 
-						codegen.opcodes.push_back(GDScriptFunction::OPCODE_RETURN);
+						codegen.opcodes.push_back(CScriptFunction::OPCODE_RETURN);
 						codegen.opcodes.push_back(ret2);
 
 					} break;
 				}
 			} break;
-			case GDScriptParser::Node::TYPE_ASSERT: {
+			case CScriptParser::Node::TYPE_ASSERT: {
 #ifdef DEBUG_ENABLED
 				// try subblocks
 
-				const GDScriptParser::AssertNode *as = static_cast<const GDScriptParser::AssertNode *>(s);
+				const CScriptParser::AssertNode *as = static_cast<const CScriptParser::AssertNode *>(s);
 
 				int ret2 = _parse_expression(codegen, as->condition, p_stack_level, false);
 				if (ret2 < 0) {
@@ -1582,19 +1582,19 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 					}
 				}
 
-				codegen.opcodes.push_back(GDScriptFunction::OPCODE_ASSERT);
+				codegen.opcodes.push_back(CScriptFunction::OPCODE_ASSERT);
 				codegen.opcodes.push_back(ret2);
 				codegen.opcodes.push_back(message_ret);
 #endif
 			} break;
-			case GDScriptParser::Node::TYPE_BREAKPOINT: {
+			case CScriptParser::Node::TYPE_BREAKPOINT: {
 #ifdef DEBUG_ENABLED
 				// try subblocks
-				codegen.opcodes.push_back(GDScriptFunction::OPCODE_BREAKPOINT);
+				codegen.opcodes.push_back(CScriptFunction::OPCODE_BREAKPOINT);
 #endif
 			} break;
-			case GDScriptParser::Node::TYPE_LOCAL_VAR: {
-				const GDScriptParser::LocalVarNode *lv = static_cast<const GDScriptParser::LocalVarNode *>(s);
+			case CScriptParser::Node::TYPE_LOCAL_VAR: {
+				const CScriptParser::LocalVarNode *lv = static_cast<const CScriptParser::LocalVarNode *>(s);
 
 				// since we are using properties now for most class access, allow shadowing of class members to make user's life easier.
 				//
@@ -1621,7 +1621,7 @@ Error GDScriptCompiler::_parse_block(CodeGen &codegen, const GDScriptParser::Blo
 	return OK;
 }
 
-Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::FunctionNode *p_func, bool p_for_ready) {
+Error CScriptCompiler::_parse_function(CScript *p_script, const CScriptParser::ClassNode *p_class, const CScriptParser::FunctionNode *p_func, bool p_for_ready) {
 	Vector<int> bytecode;
 	CodeGen codegen;
 
@@ -1663,10 +1663,10 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		//parse initializer for class members
 		if (!p_func && p_class->extends_used && p_script->native.is_null()) {
 			//call implicit parent constructor
-			codegen.opcodes.push_back(GDScriptFunction::OPCODE_CALL_SELF_BASE);
+			codegen.opcodes.push_back(CScriptFunction::OPCODE_CALL_SELF_BASE);
 			codegen.opcodes.push_back(codegen.get_name_map_pos("_init"));
 			codegen.opcodes.push_back(0);
-			codegen.opcodes.push_back((GDScriptFunction::ADDR_TYPE_STACK << GDScriptFunction::ADDR_BITS) | 0);
+			codegen.opcodes.push_back((CScriptFunction::ADDR_TYPE_STACK << CScriptFunction::ADDR_BITS) | 0);
 		}
 		Error err = _parse_block(codegen, p_class->initializer, stack_level);
 		if (err) {
@@ -1692,7 +1692,7 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 
 	if (p_func) {
 		if (p_func->default_values.size()) {
-			codegen.opcodes.push_back(GDScriptFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
+			codegen.opcodes.push_back(CScriptFunction::OPCODE_JUMP_TO_DEF_ARGUMENT);
 			defarg_addr.push_back(codegen.opcodes.size());
 			for (int i = 0; i < p_func->default_values.size(); i++) {
 				_parse_expression(codegen, p_func->default_values[i], stack_level, true);
@@ -1716,15 +1716,15 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 		}
 	}
 
-	codegen.opcodes.push_back(GDScriptFunction::OPCODE_END);
+	codegen.opcodes.push_back(CScriptFunction::OPCODE_END);
 
 	/*
 	if (String(p_func->name)=="") { //initializer func
 		gdfunc = &p_script->initializer;
 	*/
 	//} else { //regular func
-	p_script->member_functions[func_name] = memnew(GDScriptFunction);
-	GDScriptFunction *gdfunc = p_script->member_functions[func_name];
+	p_script->member_functions[func_name] = memnew(CScriptFunction);
+	CScriptFunction *gdfunc = p_script->member_functions[func_name];
 	//}
 
 	if (p_func) {
@@ -1738,9 +1738,9 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 	} else {
 		gdfunc->_static = false;
 		gdfunc->rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
-		gdfunc->return_type = GDScriptDataType();
+		gdfunc->return_type = CScriptDataType();
 		gdfunc->return_type.has_type = true;
-		gdfunc->return_type.kind = GDScriptDataType::BUILTIN;
+		gdfunc->return_type.kind = CScriptDataType::BUILTIN;
 		gdfunc->return_type.builtin_type = Variant::NIL;
 	}
 
@@ -1867,7 +1867,7 @@ Error GDScriptCompiler::_parse_function(GDScript *p_script, const GDScriptParser
 	return OK;
 }
 
-Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+Error CScriptCompiler::_parse_class_level(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state) {
 	parsing_classes.insert(p_script);
 
 	if (p_class->owner && p_class->owner->owner) {
@@ -1884,12 +1884,12 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 		}
 	}
 
-	p_script->native = Ref<GDScriptNativeClass>();
-	p_script->base = Ref<GDScript>();
+	p_script->native = Ref<CScriptNativeClass>();
+	p_script->base = Ref<CScript>();
 	p_script->_base = nullptr;
 	p_script->members.clear();
 	p_script->constants.clear();
-	for (Map<StringName, GDScriptFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) {
+	for (Map<StringName, CScriptFunction *>::Element *E = p_script->member_functions.front(); E; E = E->next()) {
 		memdelete(E->get());
 	}
 	p_script->member_functions.clear();
@@ -1901,24 +1901,24 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 	p_script->tool = p_class->tool;
 	p_script->name = p_class->name;
 
-	Ref<GDScriptNativeClass> native;
+	Ref<CScriptNativeClass> native;
 
-	GDScriptDataType base_type = _gdtype_from_datatype(p_class->base_type);
+	CScriptDataType base_type = _gdtype_from_datatype(p_class->base_type);
 	// Inheritance
 	switch (base_type.kind) {
-		case GDScriptDataType::NATIVE: {
-			int native_idx = GDScriptLanguage::get_singleton()->get_global_map()[base_type.native_type];
-			native = GDScriptLanguage::get_singleton()->get_global_array()[native_idx];
+		case CScriptDataType::NATIVE: {
+			int native_idx = CScriptLanguage::get_singleton()->get_global_map()[base_type.native_type];
+			native = CScriptLanguage::get_singleton()->get_global_array()[native_idx];
 			ERR_FAIL_COND_V(native.is_null(), ERR_BUG);
 			p_script->native = native;
 		} break;
-		case GDScriptDataType::GDSCRIPT: {
-			Ref<GDScript> base = Ref<Script>(base_type.script_type);
+		case CScriptDataType::CSCRIPT: {
+			Ref<CScript> base = Ref<Script>(base_type.script_type);
 			p_script->base = base;
 			p_script->_base = base.ptr();
 			p_script->member_indices = base->member_indices;
 
-			if (p_class->base_type.kind == GDScriptParser::DataType::CLASS) {
+			if (p_class->base_type.kind == CScriptParser::DataType::CLASS) {
 				if (!parsed_classes.has(p_script->_base)) {
 					if (parsing_classes.has(p_script->_base)) {
 						_set_error("Cyclic class reference for '" + String(p_class->name) + "'.", p_class);
@@ -1940,7 +1940,7 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 	for (int i = 0; i < p_class->variables.size(); i++) {
 		StringName name = p_class->variables[i].identifier;
 
-		GDScript::MemberInfo minfo;
+		CScript::MemberInfo minfo;
 		minfo.index = p_script->member_indices.size();
 		minfo.setter = p_class->variables[i].setter;
 		minfo.getter = p_class->variables[i].getter;
@@ -1977,12 +1977,12 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 #endif
 	}
 
-	for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
+	for (Map<StringName, CScriptParser::ClassNode::Constant>::Element *E = p_class->constant_expressions.front(); E; E = E->next()) {
 		StringName name = E->key();
 
-		ERR_CONTINUE(E->get().expression->type != GDScriptParser::Node::TYPE_CONSTANT);
+		ERR_CONTINUE(E->get().expression->type != CScriptParser::Node::TYPE_CONSTANT);
 
-		GDScriptParser::ConstantNode *constant = static_cast<GDScriptParser::ConstantNode *>(E->get().expression);
+		CScriptParser::ConstantNode *constant = static_cast<CScriptParser::ConstantNode *>(E->get().expression);
 
 		p_script->constants.insert(name, constant->value);
 #ifdef TOOLS_ENABLED
@@ -1994,7 +1994,7 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 	for (int i = 0; i < p_class->_signals.size(); i++) {
 		StringName name = p_class->_signals[i].name;
 
-		GDScript *c = p_script;
+		CScript *c = p_script;
 
 		while (c) {
 			if (c->_signals.has(name)) {
@@ -2026,8 +2026,8 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 
 	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		StringName name = p_class->subclasses[i]->name;
-		Ref<GDScript> &subclass = p_script->subclasses[name];
-		GDScript *subclass_ptr = subclass.ptr();
+		Ref<CScript> &subclass = p_script->subclasses[name];
+		CScript *subclass_ptr = subclass.ptr();
 
 		// Subclass might still be parsing, just skip it
 		if (!parsed_classes.has(subclass_ptr) && !parsing_classes.has(subclass_ptr)) {
@@ -2048,7 +2048,7 @@ Error GDScriptCompiler::_parse_class_level(GDScript *p_script, const GDScriptPar
 	return OK;
 }
 
-Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
+Error CScriptCompiler::_parse_class_blocks(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state) {
 	//parse methods
 
 	bool has_initializer = false;
@@ -2109,14 +2109,14 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 					//re-create as an instance
 					p_script->placeholders.erase(psi); //remove placeholder
 
-					GDScriptInstance *instance = memnew(GDScriptInstance);
+					CScriptInstance *instance = memnew(CScriptInstance);
 					instance->base_ref = Object::cast_to<Reference>(E->get());
 					instance->members.resize(p_script->member_indices.size());
-					instance->script = Ref<GDScript>(p_script);
+					instance->script = Ref<CScript>(p_script);
 					instance->owner = E->get();
 
 					//needed for hot reloading
-					for (Map<StringName, GDScript::MemberInfo>::Element *F = p_script->member_indices.front(); F; F = F->next()) {
+					for (Map<StringName, CScript::MemberInfo>::Element *F = p_script->member_indices.front(); F; F = F->next()) {
 						instance->member_indices_cache[F->key()] = F->get().index;
 					}
 					instance->owner->set_script_instance(instance);
@@ -2132,7 +2132,7 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 				}
 #endif
 			} else {
-				GDScriptInstance *gi = static_cast<GDScriptInstance *>(si);
+				CScriptInstance *gi = static_cast<CScriptInstance *>(si);
 				gi->reload_members();
 			}
 
@@ -2143,7 +2143,7 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 
 	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		StringName name = p_class->subclasses[i]->name;
-		GDScript *subclass = p_script->subclasses[name].ptr();
+		CScript *subclass = p_script->subclasses[name].ptr();
 
 		Error err = _parse_class_blocks(subclass, p_class->subclasses[i], p_keep_state);
 		if (err) {
@@ -2155,8 +2155,8 @@ Error GDScriptCompiler::_parse_class_blocks(GDScript *p_script, const GDScriptPa
 	return OK;
 }
 
-void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state) {
-	Map<StringName, Ref<GDScript>> old_subclasses;
+void CScriptCompiler::_make_scripts(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state) {
+	Map<StringName, Ref<CScript>> old_subclasses;
 
 	if (p_keep_state) {
 		old_subclasses = p_script->subclasses;
@@ -2167,13 +2167,13 @@ void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::C
 	for (int i = 0; i < p_class->subclasses.size(); i++) {
 		StringName name = p_class->subclasses[i]->name;
 
-		Ref<GDScript> subclass;
+		Ref<CScript> subclass;
 		String fully_qualified_name = p_script->fully_qualified_name + "::" + name;
 
 		if (old_subclasses.has(name)) {
 			subclass = old_subclasses[name];
 		} else {
-			Ref<GDScript> orphan_subclass = GDScriptLanguage::get_singleton()->get_orphan_subclass(fully_qualified_name);
+			Ref<CScript> orphan_subclass = CScriptLanguage::get_singleton()->get_orphan_subclass(fully_qualified_name);
 			if (orphan_subclass.is_valid()) {
 				subclass = orphan_subclass;
 			} else {
@@ -2189,14 +2189,14 @@ void GDScriptCompiler::_make_scripts(GDScript *p_script, const GDScriptParser::C
 	}
 }
 
-Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_script, bool p_keep_state) {
+Error CScriptCompiler::compile(const CScriptParser *p_parser, CScript *p_script, bool p_keep_state) {
 	err_line = -1;
 	err_column = -1;
 	error = "";
 	parser = p_parser;
 	main_script = p_script;
-	const GDScriptParser::Node *root = parser->get_parse_tree();
-	ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, ERR_INVALID_DATA);
+	const CScriptParser::Node *root = parser->get_parse_tree();
+	ERR_FAIL_COND_V(root->type != CScriptParser::Node::TYPE_CLASS, ERR_INVALID_DATA);
 
 	source = p_script->get_path();
 
@@ -2204,16 +2204,16 @@ Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_scri
 	p_script->fully_qualified_name = p_script->path;
 
 	// Create scripts for subclasses beforehand so they can be referenced
-	_make_scripts(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+	_make_scripts(p_script, static_cast<const CScriptParser::ClassNode *>(root), p_keep_state);
 
 	p_script->_owner = nullptr;
-	Error err = _parse_class_level(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+	Error err = _parse_class_level(p_script, static_cast<const CScriptParser::ClassNode *>(root), p_keep_state);
 
 	if (err) {
 		return err;
 	}
 
-	err = _parse_class_blocks(p_script, static_cast<const GDScriptParser::ClassNode *>(root), p_keep_state);
+	err = _parse_class_blocks(p_script, static_cast<const CScriptParser::ClassNode *>(root), p_keep_state);
 
 	if (err) {
 		return err;
@@ -2222,15 +2222,15 @@ Error GDScriptCompiler::compile(const GDScriptParser *p_parser, GDScript *p_scri
 	return OK;
 }
 
-String GDScriptCompiler::get_error() const {
+String CScriptCompiler::get_error() const {
 	return error;
 }
-int GDScriptCompiler::get_error_line() const {
+int CScriptCompiler::get_error_line() const {
 	return err_line;
 }
-int GDScriptCompiler::get_error_column() const {
+int CScriptCompiler::get_error_column() const {
 	return err_column;
 }
 
-GDScriptCompiler::GDScriptCompiler() {
+CScriptCompiler::CScriptCompiler() {
 }
diff --git a/modules/cscript/cscript_compiler.h b/modules/cscript/cscript_compiler.h
index 6fcef29b4..97cde600a 100644
--- a/modules/cscript/cscript_compiler.h
+++ b/modules/cscript/cscript_compiler.h
@@ -34,21 +34,21 @@
 #include "cscript.h"
 #include "cscript_parser.h"
 
-class GDScriptCompiler {
-	const GDScriptParser *parser;
-	Set<GDScript *> parsed_classes;
-	Set<GDScript *> parsing_classes;
-	GDScript *main_script;
+class CScriptCompiler {
+	const CScriptParser *parser;
+	Set<CScript *> parsed_classes;
+	Set<CScript *> parsing_classes;
+	CScript *main_script;
 	struct CodeGen {
-		GDScript *script;
-		const GDScriptParser::ClassNode *class_node;
-		const GDScriptParser::FunctionNode *function_node;
+		CScript *script;
+		const CScriptParser::ClassNode *class_node;
+		const CScriptParser::FunctionNode *function_node;
 		bool debug_stack;
 
 		List<Map<StringName, int>> stack_id_stack;
 		Map<StringName, int> stack_identifiers;
 
-		List<GDScriptFunction::StackDebug> stack_debug;
+		List<CScriptFunction::StackDebug> stack_debug;
 		List<Map<StringName, int>> block_identifier_stack;
 		Map<StringName, int> block_identifiers;
 
@@ -56,7 +56,7 @@ class GDScriptCompiler {
 			stack_identifiers[p_id] = p_stackpos;
 			if (debug_stack) {
 				block_identifiers[p_id] = p_stackpos;
-				GDScriptFunction::StackDebug sd;
+				CScriptFunction::StackDebug sd;
 				sd.added = true;
 				sd.line = current_line;
 				sd.identifier = p_id;
@@ -79,7 +79,7 @@ class GDScriptCompiler {
 
 			if (debug_stack) {
 				for (Map<StringName, int>::Element *E = block_identifiers.front(); E; E = E->next()) {
-					GDScriptFunction::StackDebug sd;
+					CScriptFunction::StackDebug sd;
 					sd.added = false;
 					sd.identifier = E->key();
 					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(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_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_unary_operator(CodeGen &codegen, const CScriptParser::OperatorNode *on, Variant::Operator op, int p_stack_level);
+	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_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);
-	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_function(GDScript *p_script, const GDScriptParser::ClassNode *p_class, const GDScriptParser::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_blocks(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
-	void _make_scripts(GDScript *p_script, const GDScriptParser::ClassNode *p_class, bool p_keep_state);
+	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 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 CScriptParser::BlockNode *p_block, int p_stack_level = 0, int p_break_addr = -1, int p_continue_addr = -1);
+	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(CScript *p_script, const CScriptParser::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(CScript *p_script, const CScriptParser::ClassNode *p_class, bool p_keep_state);
 	int err_line;
 	int err_column;
 	StringName source;
 	String error;
 
 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;
 	int get_error_line() const;
 	int get_error_column() const;
 
-	GDScriptCompiler();
+	CScriptCompiler();
 };
 
-#endif // GDSCRIPT_COMPILER_H
+#endif // CSCRIPT_COMPILER_H
diff --git a/modules/cscript/cscript_editor.cpp b/modules/cscript/cscript_editor.cpp
index d57bbb028..bd6c50b42 100644
--- a/modules/cscript/cscript_editor.cpp
+++ b/modules/cscript/cscript_editor.cpp
@@ -41,17 +41,17 @@
 #include "editor/editor_settings.h"
 #endif
 
-void GDScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+void CScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
 	p_delimiters->push_back("#");
 }
 
-void GDScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+void CScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
 	p_delimiters->push_back("\"\"\" \"\"\"");
 	p_delimiters->push_back("\" \"");
 	p_delimiters->push_back("' '");
 }
 
-String GDScriptLanguage::_get_processed_template(const String &p_template, const String &p_base_class_name) const {
+String CScriptLanguage::_get_processed_template(const String &p_template, const String &p_base_class_name) const {
 	String processed_template = p_template;
 
 #ifdef TOOLS_ENABLED
@@ -79,7 +79,7 @@ String GDScriptLanguage::_get_processed_template(const String &p_template, const
 	return processed_template;
 }
 
-Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
+Ref<Script> CScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
 	String _template = "extends %BASE%\n"
 					   "\n"
 					   "\n"
@@ -99,34 +99,34 @@ Ref<Script> GDScriptLanguage::get_template(const String &p_class_name, const Str
 
 	_template = _get_processed_template(_template, p_base_class_name);
 
-	Ref<GDScript> script;
+	Ref<CScript> script;
 	script.instance();
 	script->set_source_code(_template);
 
 	return script;
 }
 
-bool GDScriptLanguage::is_using_templates() {
+bool CScriptLanguage::is_using_templates() {
 	return true;
 }
 
-void GDScriptLanguage::make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script) {
+void CScriptLanguage::make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script) {
 	String _template = _get_processed_template(p_script->get_source_code(), p_base_class_name);
 	p_script->set_source_code(_template);
 }
 
-bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings, Set<int> *r_safe_lines) const {
-	GDScriptParser parser;
+bool CScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings, Set<int> *r_safe_lines) const {
+	CScriptParser parser;
 
 	Error err = parser.parse(p_script, p_path.get_base_dir(), true, p_path, false, r_safe_lines);
 #ifdef DEBUG_ENABLED
 	if (r_warnings) {
-		for (const List<GDScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
-			const GDScriptWarning &warn = E->get();
+		for (const List<CScriptWarning>::Element *E = parser.get_warnings().front(); E; E = E->next()) {
+			const CScriptWarning &warn = E->get();
 			ScriptLanguage::Warning w;
 			w.line = warn.line;
 			w.code = (int)warn.code;
-			w.string_code = GDScriptWarning::get_name_from_code(warn.code);
+			w.string_code = CScriptWarning::get_name_from_code(warn.code);
 			w.message = warn.get_message();
 			r_warnings->push_back(w);
 		}
@@ -138,10 +138,10 @@ bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &
 		r_test_error = parser.get_error();
 		return false;
 	} else {
-		const GDScriptParser::Node *root = parser.get_parse_tree();
-		ERR_FAIL_COND_V(root->type != GDScriptParser::Node::TYPE_CLASS, false);
+		const CScriptParser::Node *root = parser.get_parse_tree();
+		ERR_FAIL_COND_V(root->type != CScriptParser::Node::TYPE_CLASS, false);
 
-		const GDScriptParser::ClassNode *cl = static_cast<const GDScriptParser::ClassNode *>(root);
+		const CScriptParser::ClassNode *cl = static_cast<const CScriptParser::ClassNode *>(root);
 		Map<int, String> funcs;
 		for (int i = 0; i < cl->functions.size(); i++) {
 			funcs[cl->functions[i]->line] = cl->functions[i]->name;
@@ -168,23 +168,23 @@ bool GDScriptLanguage::validate(const String &p_script, int &r_line_error, int &
 	return true;
 }
 
-bool GDScriptLanguage::has_named_classes() const {
+bool CScriptLanguage::has_named_classes() const {
 	return false;
 }
 
-bool GDScriptLanguage::supports_builtin_mode() const {
+bool CScriptLanguage::supports_builtin_mode() const {
 	return true;
 }
 
-int GDScriptLanguage::find_function(const String &p_function, const String &p_code) const {
-	GDScriptTokenizerText tokenizer;
+int CScriptLanguage::find_function(const String &p_function, const String &p_code) const {
+	CScriptTokenizerText tokenizer;
 	tokenizer.set_code(p_code);
 	int indent = 0;
-	while (tokenizer.get_token() != GDScriptTokenizer::TK_EOF && tokenizer.get_token() != GDScriptTokenizer::TK_ERROR) {
-		if (tokenizer.get_token() == GDScriptTokenizer::TK_NEWLINE) {
+	while (tokenizer.get_token() != CScriptTokenizer::TK_EOF && tokenizer.get_token() != CScriptTokenizer::TK_ERROR) {
+		if (tokenizer.get_token() == CScriptTokenizer::TK_NEWLINE) {
 			indent = tokenizer.get_token_line_indent();
 		}
-		if (indent == 0 && tokenizer.get_token() == GDScriptTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1) == GDScriptTokenizer::TK_IDENTIFIER) {
+		if (indent == 0 && tokenizer.get_token() == CScriptTokenizer::TK_PR_FUNCTION && tokenizer.get_token(1) == CScriptTokenizer::TK_IDENTIFIER) {
 			String identifier = tokenizer.get_token_identifier(1);
 			if (identifier == p_function) {
 				return tokenizer.get_token_line();
@@ -195,13 +195,13 @@ int GDScriptLanguage::find_function(const String &p_function, const String &p_co
 	return -1;
 }
 
-Script *GDScriptLanguage::create_script() const {
-	return memnew(GDScript);
+Script *CScriptLanguage::create_script() const {
+	return memnew(CScript);
 }
 
 /* DEBUGGER FUNCTIONS */
 
-bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
+bool CScriptLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {
 	//break because of parse error
 
 	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
@@ -215,7 +215,7 @@ bool GDScriptLanguage::debug_break_parse(const String &p_file, int p_line, const
 	}
 }
 
-bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
+bool CScriptLanguage::debug_break(const String &p_error, bool p_allow_continue) {
 	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
 		_debug_parse_err_line = -1;
 		_debug_parse_err_file = "";
@@ -228,18 +228,18 @@ bool GDScriptLanguage::debug_break(const String &p_error, bool p_allow_continue)
 	}
 }
 
-String GDScriptLanguage::debug_get_error() const {
+String CScriptLanguage::debug_get_error() const {
 	return _debug_error;
 }
 
-int GDScriptLanguage::debug_get_stack_level_count() const {
+int CScriptLanguage::debug_get_stack_level_count() const {
 	if (_debug_parse_err_line >= 0) {
 		return 1;
 	}
 
 	return _debug_call_stack_pos;
 }
-int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
+int CScriptLanguage::debug_get_stack_level_line(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_line;
 	}
@@ -250,7 +250,7 @@ int GDScriptLanguage::debug_get_stack_level_line(int p_level) const {
 
 	return *(_call_stack[l].line);
 }
-String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
+String CScriptLanguage::debug_get_stack_level_function(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return "";
 	}
@@ -259,7 +259,7 @@ String GDScriptLanguage::debug_get_stack_level_function(int p_level) const {
 	int l = _debug_call_stack_pos - p_level - 1;
 	return _call_stack[l].function->get_name();
 }
-String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
+String CScriptLanguage::debug_get_stack_level_source(int p_level) const {
 	if (_debug_parse_err_line >= 0) {
 		return _debug_parse_err_file;
 	}
@@ -268,7 +268,7 @@ String GDScriptLanguage::debug_get_stack_level_source(int p_level) const {
 	int l = _debug_call_stack_pos - p_level - 1;
 	return _call_stack[l].function->get_source();
 }
-void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+void CScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 	if (_debug_parse_err_line >= 0) {
 		return;
 	}
@@ -276,7 +276,7 @@ void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p
 	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
 	int l = _debug_call_stack_pos - p_level - 1;
 
-	GDScriptFunction *f = _call_stack[l].function;
+	CScriptFunction *f = _call_stack[l].function;
 
 	List<Pair<StringName, int>> locals;
 
@@ -286,7 +286,7 @@ void GDScriptLanguage::debug_get_stack_level_locals(int p_level, List<String> *p
 		p_values->push_back(_call_stack[l].stack[E->get().second]);
 	}
 }
-void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+void CScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
 	if (_debug_parse_err_line >= 0) {
 		return;
 	}
@@ -294,24 +294,24 @@ void GDScriptLanguage::debug_get_stack_level_members(int p_level, List<String> *
 	ERR_FAIL_INDEX(p_level, _debug_call_stack_pos);
 	int l = _debug_call_stack_pos - p_level - 1;
 
-	GDScriptInstance *instance = _call_stack[l].instance;
+	CScriptInstance *instance = _call_stack[l].instance;
 
 	if (!instance) {
 		return;
 	}
 
-	Ref<GDScript> script = instance->get_script();
+	Ref<CScript> script = instance->get_script();
 	ERR_FAIL_COND(script.is_null());
 
-	const Map<StringName, GDScript::MemberInfo> &mi = script->debug_get_member_indices();
+	const Map<StringName, CScript::MemberInfo> &mi = script->debug_get_member_indices();
 
-	for (const Map<StringName, GDScript::MemberInfo>::Element *E = mi.front(); E; E = E->next()) {
+	for (const Map<StringName, CScript::MemberInfo>::Element *E = mi.front(); E; E = E->next()) {
 		p_members->push_back(E->key());
 		p_values->push_back(instance->debug_get_member_by_index(E->get().index));
 	}
 }
 
-ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
+ScriptInstance *CScriptLanguage::debug_get_stack_level_instance(int p_level) {
 	if (_debug_parse_err_line >= 0) {
 		return nullptr;
 	}
@@ -324,9 +324,9 @@ ScriptInstance *GDScriptLanguage::debug_get_stack_level_instance(int p_level) {
 	return instance;
 }
 
-void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
-	const Map<StringName, int> &name_idx = GDScriptLanguage::get_singleton()->get_global_map();
-	const Variant *globals = GDScriptLanguage::get_singleton()->get_global_array();
+void CScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {
+	const Map<StringName, int> &name_idx = CScriptLanguage::get_singleton()->get_global_map();
+	const Variant *globals = CScriptLanguage::get_singleton()->get_global_array();
 
 	List<Pair<String, Variant>> cinfo;
 	get_public_constants(&cinfo);
@@ -349,7 +349,7 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 
 		const Variant &var = globals[E->value()];
 		if (Object *obj = var) {
-			if (Object::cast_to<GDScriptNativeClass>(obj)) {
+			if (Object::cast_to<CScriptNativeClass>(obj)) {
 				continue;
 			}
 		}
@@ -370,17 +370,17 @@ void GDScriptLanguage::debug_get_globals(List<String> *p_globals, List<Variant>
 	}
 }
 
-String GDScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
+String CScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
 	return "";
 }
 
-void GDScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+void CScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_back("gd");
 }
 
-void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
-	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
-		p_functions->push_back(GDScriptFunctions::get_info(GDScriptFunctions::Function(i)));
+void CScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
+	for (int i = 0; i < CScriptFunctions::FUNC_MAX; i++) {
+		p_functions->push_back(CScriptFunctions::get_info(CScriptFunctions::Function(i)));
 	}
 
 	//not really "functions", but..
@@ -398,7 +398,7 @@ void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const
 		mi.arguments.push_back(PropertyInfo(Variant::STRING, "signal"));
 		mi.default_arguments.push_back(Variant());
 		mi.default_arguments.push_back(String());
-		mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "GDScriptFunctionState");
+		mi.return_val = PropertyInfo(Variant::OBJECT, "", PROPERTY_HINT_RESOURCE_TYPE, "CScriptFunctionState");
 		p_functions->push_back(mi);
 	}
 	{
@@ -412,7 +412,7 @@ void GDScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const
 	}
 }
 
-void GDScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_constants) const {
+void CScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_constants) const {
 	Pair<String, Variant> pi;
 	pi.first = "PI";
 	pi.second = Math_PI;
@@ -434,7 +434,7 @@ void GDScriptLanguage::get_public_constants(List<Pair<String, Variant>> *p_const
 	p_constants->push_back(nan);
 }
 
-String GDScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
+String CScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
 #ifdef TOOLS_ENABLED
 	bool th = EditorSettings::get_singleton()->get_setting("text_editor/completion/add_type_hints");
 #else
@@ -465,16 +465,16 @@ String GDScriptLanguage::make_function(const String &p_class, const String &p_na
 
 #if defined(DEBUG_METHODS_ENABLED) && defined(TOOLS_ENABLED)
 
-struct GDScriptCompletionContext {
-	const GDScriptParser::ClassNode *_class;
-	const GDScriptParser::FunctionNode *function;
-	const GDScriptParser::BlockNode *block;
+struct CScriptCompletionContext {
+	const CScriptParser::ClassNode *_class;
+	const CScriptParser::FunctionNode *function;
+	const CScriptParser::BlockNode *block;
 	Object *base;
 	String base_path;
 	int line;
 	uint32_t depth;
 
-	GDScriptCompletionContext() :
+	CScriptCompletionContext() :
 			_class(nullptr),
 			function(nullptr),
 			block(nullptr),
@@ -483,13 +483,13 @@ struct GDScriptCompletionContext {
 			depth(0) {}
 };
 
-struct GDScriptCompletionIdentifier {
-	GDScriptParser::DataType type;
+struct CScriptCompletionIdentifier {
+	CScriptParser::DataType type;
 	String enumeration;
 	Variant value;
-	const GDScriptParser::Node *assigned_expression;
+	const CScriptParser::Node *assigned_expression;
 
-	GDScriptCompletionIdentifier() :
+	CScriptCompletionIdentifier() :
 			assigned_expression(nullptr) {}
 };
 
@@ -546,12 +546,12 @@ static String _get_visual_datatype(const PropertyInfo &p_info, bool p_isarg = tr
 	return Variant::get_type_name(p_info.type);
 }
 
-static GDScriptCompletionIdentifier _type_from_variant(const Variant &p_value) {
-	GDScriptCompletionIdentifier ci;
+static CScriptCompletionIdentifier _type_from_variant(const Variant &p_value) {
+	CScriptCompletionIdentifier ci;
 	ci.value = p_value;
 	ci.type.is_constant = true;
 	ci.type.has_type = true;
-	ci.type.kind = GDScriptParser::DataType::BUILTIN;
+	ci.type.kind = CScriptParser::DataType::BUILTIN;
 	ci.type.builtin_type = p_value.get_type();
 
 	if (ci.type.builtin_type == Variant::OBJECT) {
@@ -569,23 +569,23 @@ static GDScriptCompletionIdentifier _type_from_variant(const Variant &p_value) {
 		}
 		if (scr.is_valid()) {
 			ci.type.script_type = scr;
-			Ref<GDScript> gds = scr;
+			Ref<CScript> gds = scr;
 			if (gds.is_valid()) {
-				ci.type.kind = GDScriptParser::DataType::GDSCRIPT;
+				ci.type.kind = CScriptParser::DataType::CSCRIPT;
 			} else {
-				ci.type.kind = GDScriptParser::DataType::SCRIPT;
+				ci.type.kind = CScriptParser::DataType::SCRIPT;
 			}
 			ci.type.native_type = scr->get_instance_base_type();
 		} else {
-			ci.type.kind = GDScriptParser::DataType::NATIVE;
+			ci.type.kind = CScriptParser::DataType::NATIVE;
 		}
 	}
 
 	return ci;
 }
 
-static GDScriptCompletionIdentifier _type_from_property(const PropertyInfo &p_property) {
-	GDScriptCompletionIdentifier ci;
+static CScriptCompletionIdentifier _type_from_property(const PropertyInfo &p_property) {
+	CScriptCompletionIdentifier ci;
 
 	if (p_property.type == Variant::NIL) {
 		// Variant
@@ -599,16 +599,16 @@ static GDScriptCompletionIdentifier _type_from_property(const PropertyInfo &p_pr
 	ci.type.has_type = true;
 	ci.type.builtin_type = p_property.type;
 	if (p_property.type == Variant::OBJECT) {
-		ci.type.kind = GDScriptParser::DataType::NATIVE;
+		ci.type.kind = CScriptParser::DataType::NATIVE;
 		ci.type.native_type = p_property.class_name == StringName() ? "Object" : p_property.class_name;
 	} else {
-		ci.type.kind = GDScriptParser::DataType::BUILTIN;
+		ci.type.kind = CScriptParser::DataType::BUILTIN;
 	}
 	return ci;
 }
 
-static GDScriptCompletionIdentifier _type_from_gdtype(const GDScriptDataType &p_gdtype) {
-	GDScriptCompletionIdentifier ci;
+static CScriptCompletionIdentifier _type_from_gdtype(const CScriptDataType &p_gdtype) {
+	CScriptCompletionIdentifier ci;
 	if (!p_gdtype.has_type) {
 		return ci;
 	}
@@ -619,30 +619,30 @@ static GDScriptCompletionIdentifier _type_from_gdtype(const GDScriptDataType &p_
 	ci.type.script_type = Ref<Script>(p_gdtype.script_type);
 
 	switch (p_gdtype.kind) {
-		case GDScriptDataType::UNINITIALIZED: {
+		case CScriptDataType::UNINITIALIZED: {
 			ERR_PRINT("Uninitialized completion. Please report a bug.");
 		} break;
-		case GDScriptDataType::BUILTIN: {
-			ci.type.kind = GDScriptParser::DataType::BUILTIN;
+		case CScriptDataType::BUILTIN: {
+			ci.type.kind = CScriptParser::DataType::BUILTIN;
 		} break;
-		case GDScriptDataType::NATIVE: {
-			ci.type.kind = GDScriptParser::DataType::NATIVE;
+		case CScriptDataType::NATIVE: {
+			ci.type.kind = CScriptParser::DataType::NATIVE;
 		} break;
-		case GDScriptDataType::GDSCRIPT: {
-			ci.type.kind = GDScriptParser::DataType::GDSCRIPT;
+		case CScriptDataType::CSCRIPT: {
+			ci.type.kind = CScriptParser::DataType::CSCRIPT;
 		} break;
-		case GDScriptDataType::SCRIPT: {
-			ci.type.kind = GDScriptParser::DataType::SCRIPT;
+		case CScriptDataType::SCRIPT: {
+			ci.type.kind = CScriptParser::DataType::SCRIPT;
 		} break;
 	}
 	return ci;
 }
 
-static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type);
-static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type);
-static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type);
+static bool _guess_identifier_type(CScriptCompletionContext &p_context, const StringName &p_identifier, CScriptCompletionIdentifier &r_type);
+static bool _guess_identifier_type_from_base(CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, const StringName &p_identifier, CScriptCompletionIdentifier &r_type);
+static bool _guess_method_return_type_from_base(CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, const StringName &p_method, CScriptCompletionIdentifier &r_type);
 
-static bool _guess_expression_type(GDScriptCompletionContext &p_context, const GDScriptParser::Node *p_expression, GDScriptCompletionIdentifier &r_type) {
+static bool _guess_expression_type(CScriptCompletionContext &p_context, const CScriptParser::Node *p_expression, CScriptCompletionIdentifier &r_type) {
 	bool found = false;
 
 	if (++p_context.depth > 100) {
@@ -651,34 +651,34 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 	}
 
 	switch (p_expression->type) {
-		case GDScriptParser::Node::TYPE_CONSTANT: {
-			const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(p_expression);
+		case CScriptParser::Node::TYPE_CONSTANT: {
+			const CScriptParser::ConstantNode *cn = static_cast<const CScriptParser::ConstantNode *>(p_expression);
 			r_type = _type_from_variant(cn->value);
 			found = true;
 		} break;
-		case GDScriptParser::Node::TYPE_SELF: {
+		case CScriptParser::Node::TYPE_SELF: {
 			if (p_context._class) {
 				r_type.type.has_type = true;
-				r_type.type.kind = GDScriptParser::DataType::CLASS;
-				r_type.type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+				r_type.type.kind = CScriptParser::DataType::CLASS;
+				r_type.type.class_type = const_cast<CScriptParser::ClassNode *>(p_context._class);
 				r_type.type.is_constant = true;
 				r_type.value = p_context.base;
 				found = true;
 			}
 		} break;
-		case GDScriptParser::Node::TYPE_IDENTIFIER: {
-			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(p_expression);
+		case CScriptParser::Node::TYPE_IDENTIFIER: {
+			const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(p_expression);
 			found = _guess_identifier_type(p_context, id->name, r_type);
 		} break;
-		case GDScriptParser::Node::TYPE_DICTIONARY: {
+		case CScriptParser::Node::TYPE_DICTIONARY: {
 			// Try to recreate the dictionary
-			const GDScriptParser::DictionaryNode *dn = static_cast<const GDScriptParser::DictionaryNode *>(p_expression);
+			const CScriptParser::DictionaryNode *dn = static_cast<const CScriptParser::DictionaryNode *>(p_expression);
 			Dictionary d;
 			bool full = true;
 			for (int i = 0; i < dn->elements.size(); i++) {
-				GDScriptCompletionIdentifier key;
+				CScriptCompletionIdentifier key;
 				if (_guess_expression_type(p_context, dn->elements[i].key, key)) {
-					GDScriptCompletionIdentifier value;
+					CScriptCompletionIdentifier value;
 					if (_guess_expression_type(p_context, dn->elements[i].value, value)) {
 						if (!value.type.is_constant) {
 							full = false;
@@ -700,17 +700,17 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 				r_type.type.is_constant = true;
 			}
 			r_type.type.has_type = true;
-			r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+			r_type.type.kind = CScriptParser::DataType::BUILTIN;
 			r_type.type.builtin_type = Variant::DICTIONARY;
 		} break;
-		case GDScriptParser::Node::TYPE_ARRAY: {
+		case CScriptParser::Node::TYPE_ARRAY: {
 			// Try to recreate the array
-			const GDScriptParser::ArrayNode *an = static_cast<const GDScriptParser::ArrayNode *>(p_expression);
+			const CScriptParser::ArrayNode *an = static_cast<const CScriptParser::ArrayNode *>(p_expression);
 			Array a;
 			bool full = true;
 			a.resize(an->elements.size());
 			for (int i = 0; i < an->elements.size(); i++) {
-				GDScriptCompletionIdentifier value;
+				CScriptCompletionIdentifier value;
 				if (_guess_expression_type(p_context, an->elements[i], value)) {
 					a[i] = value.value;
 				} else {
@@ -723,41 +723,41 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 				r_type.value = a;
 			}
 			r_type.type.has_type = true;
-			r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+			r_type.type.kind = CScriptParser::DataType::BUILTIN;
 			r_type.type.builtin_type = Variant::ARRAY;
 		} break;
-		case GDScriptParser::Node::TYPE_CAST: {
-			const GDScriptParser::CastNode *cn = static_cast<const GDScriptParser::CastNode *>(p_expression);
-			GDScriptCompletionIdentifier value;
+		case CScriptParser::Node::TYPE_CAST: {
+			const CScriptParser::CastNode *cn = static_cast<const CScriptParser::CastNode *>(p_expression);
+			CScriptCompletionIdentifier value;
 			if (_guess_expression_type(p_context, cn->source_node, r_type)) {
 				r_type.type = cn->get_datatype();
 				found = true;
 			}
 		} break;
-		case GDScriptParser::Node::TYPE_OPERATOR: {
-			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_expression);
+		case CScriptParser::Node::TYPE_OPERATOR: {
+			const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(p_expression);
 			switch (op->op) {
-				case GDScriptParser::OperatorNode::OP_CALL: {
-					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
-						const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(op->arguments[0]);
+				case CScriptParser::OperatorNode::OP_CALL: {
+					if (op->arguments[0]->type == CScriptParser::Node::TYPE_TYPE) {
+						const CScriptParser::TypeNode *tn = static_cast<const CScriptParser::TypeNode *>(op->arguments[0]);
 						r_type.type.has_type = true;
-						r_type.type.kind = GDScriptParser::DataType::BUILTIN;
+						r_type.type.kind = CScriptParser::DataType::BUILTIN;
 						r_type.type.builtin_type = tn->vtype;
 						found = true;
 						break;
-					} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
-						const GDScriptParser::BuiltInFunctionNode *bin = static_cast<const GDScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
-						MethodInfo mi = GDScriptFunctions::get_info(bin->function);
+					} else if (op->arguments[0]->type == CScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+						const CScriptParser::BuiltInFunctionNode *bin = static_cast<const CScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
+						MethodInfo mi = CScriptFunctions::get_info(bin->function);
 						r_type = _type_from_property(mi.return_val);
 						found = true;
 						break;
-					} else if (op->arguments.size() >= 2 && op->arguments[1]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
-						StringName id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1])->name;
+					} else if (op->arguments.size() >= 2 && op->arguments[1]->type == CScriptParser::Node::TYPE_IDENTIFIER) {
+						StringName id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[1])->name;
 
-						GDScriptCompletionContext c = p_context;
+						CScriptCompletionContext c = p_context;
 						c.line = op->line;
 
-						GDScriptCompletionIdentifier base;
+						CScriptCompletionIdentifier base;
 						if (!_guess_expression_type(c, op->arguments[0], base)) {
 							found = false;
 							break;
@@ -765,19 +765,19 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 
 						// Try call if constant methods with constant arguments
 						if (base.type.is_constant && base.value.get_type() == Variant::OBJECT) {
-							GDScriptParser::DataType native_type = base.type;
+							CScriptParser::DataType native_type = base.type;
 
-							while (native_type.kind == GDScriptParser::DataType::CLASS) {
+							while (native_type.kind == CScriptParser::DataType::CLASS) {
 								native_type = native_type.class_type->base_type;
 							}
 
-							while (native_type.kind == GDScriptParser::DataType::GDSCRIPT || native_type.kind == GDScriptParser::DataType::SCRIPT) {
+							while (native_type.kind == CScriptParser::DataType::CSCRIPT || native_type.kind == CScriptParser::DataType::SCRIPT) {
 								if (native_type.script_type.is_valid()) {
 									Ref<Script> parent = native_type.script_type->get_base_script();
 									if (parent.is_valid()) {
 										native_type.script_type = parent;
 									} else {
-										native_type.kind = GDScriptParser::DataType::NATIVE;
+										native_type.kind = CScriptParser::DataType::NATIVE;
 										native_type.native_type = native_type.script_type->get_instance_base_type();
 										if (!ClassDB::class_exists(native_type.native_type)) {
 											native_type.native_type = String("_") + native_type.native_type;
@@ -789,15 +789,15 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 								}
 							}
 
-							if (native_type.has_type && native_type.kind == GDScriptParser::DataType::NATIVE) {
+							if (native_type.has_type && native_type.kind == CScriptParser::DataType::NATIVE) {
 								MethodBind *mb = ClassDB::get_method(native_type.native_type, id);
 								if (mb && mb->is_const()) {
 									bool all_is_const = true;
 									Vector<Variant> args;
-									GDScriptCompletionContext c2 = p_context;
+									CScriptCompletionContext c2 = p_context;
 									c2.line = op->line;
 									for (int i = 2; all_is_const && i < op->arguments.size(); i++) {
-										GDScriptCompletionIdentifier arg;
+										CScriptCompletionIdentifier arg;
 
 										if (_guess_expression_type(c2, op->arguments[i], arg)) {
 											if (arg.type.has_type && arg.type.is_constant && arg.value.get_type() != Variant::OBJECT) {
@@ -818,8 +818,8 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 											String which = arg1.get_slice("/", 2);
 											if (which != "") {
 												// Try singletons first
-												if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(which)) {
-													r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[which]);
+												if (CScriptLanguage::get_singleton()->get_named_globals_map().has(which)) {
+													r_type = _type_from_variant(CScriptLanguage::get_singleton()->get_named_globals_map()[which]);
 													found = true;
 												} else {
 													List<PropertyInfo> props;
@@ -859,11 +859,11 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 																	r_type.type.has_type = true;
 																	r_type.type.script_type = scr;
 																	r_type.type.is_constant = false;
-																	Ref<GDScript> gds = scr;
+																	Ref<CScript> gds = scr;
 																	if (gds.is_valid()) {
-																		r_type.type.kind = GDScriptParser::DataType::GDSCRIPT;
+																		r_type.type.kind = CScriptParser::DataType::CSCRIPT;
 																	} else {
-																		r_type.type.kind = GDScriptParser::DataType::SCRIPT;
+																		r_type.type.kind = CScriptParser::DataType::SCRIPT;
 																	}
 																	r_type.value = Variant();
 																	found = true;
@@ -902,33 +902,33 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 						}
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_PARENT_CALL: {
-					if (!p_context._class || !op->arguments.size() || op->arguments[0]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+				case CScriptParser::OperatorNode::OP_PARENT_CALL: {
+					if (!p_context._class || !op->arguments.size() || op->arguments[0]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 						break;
 					}
 
-					StringName id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name;
+					StringName id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[0])->name;
 
-					GDScriptCompletionIdentifier base;
+					CScriptCompletionIdentifier base;
 					base.value = p_context.base;
 					base.type = p_context._class->base_type;
 
-					GDScriptCompletionContext c = p_context;
+					CScriptCompletionContext c = p_context;
 					c.line = op->line;
 
 					found = _guess_method_return_type_from_base(c, base, id, r_type);
 				} break;
-				case GDScriptParser::OperatorNode::OP_INDEX_NAMED: {
-					if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+				case CScriptParser::OperatorNode::OP_INDEX_NAMED: {
+					if (op->arguments.size() < 2 || op->arguments[1]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 						found = false;
 						break;
 					}
-					const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+					const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[1]);
 
-					GDScriptCompletionContext c = p_context;
+					CScriptCompletionContext c = p_context;
 					c.line = op->line;
 
-					GDScriptCompletionIdentifier base;
+					CScriptCompletionIdentifier base;
 					if (!_guess_expression_type(c, op->arguments[0], base)) {
 						found = false;
 						break;
@@ -941,16 +941,16 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 						break;
 					}
 
-					const GDScriptParser::DictionaryNode *dn = nullptr;
-					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_DICTIONARY) {
-						dn = static_cast<const GDScriptParser::DictionaryNode *>(op->arguments[0]);
-					} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_DICTIONARY) {
-						dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
+					const CScriptParser::DictionaryNode *dn = nullptr;
+					if (op->arguments[0]->type == CScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const CScriptParser::DictionaryNode *>(op->arguments[0]);
+					} else if (base.assigned_expression && base.assigned_expression->type == CScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const CScriptParser::DictionaryNode *>(base.assigned_expression);
 					}
 
 					if (dn) {
 						for (int i = 0; i < dn->elements.size(); i++) {
-							GDScriptCompletionIdentifier key;
+							CScriptCompletionIdentifier key;
 							if (!_guess_expression_type(c, dn->elements[i].key, key)) {
 								continue;
 							}
@@ -966,22 +966,22 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 						found = _guess_identifier_type_from_base(c, base, id->name, r_type);
 					}
 				} break;
-				case GDScriptParser::OperatorNode::OP_INDEX: {
+				case CScriptParser::OperatorNode::OP_INDEX: {
 					if (op->arguments.size() < 2) {
 						found = false;
 						break;
 					}
 
-					GDScriptCompletionContext c = p_context;
+					CScriptCompletionContext c = p_context;
 					c.line = op->line;
 
-					GDScriptCompletionIdentifier base;
+					CScriptCompletionIdentifier base;
 					if (!_guess_expression_type(c, op->arguments[0], base)) {
 						found = false;
 						break;
 					}
 
-					GDScriptCompletionIdentifier index;
+					CScriptCompletionIdentifier index;
 					if (!_guess_expression_type(c, op->arguments[1], index)) {
 						found = false;
 						break;
@@ -995,16 +995,16 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 					}
 
 					// Look if it is a dictionary node
-					const GDScriptParser::DictionaryNode *dn = nullptr;
-					if (op->arguments[0]->type == GDScriptParser::Node::TYPE_DICTIONARY) {
-						dn = static_cast<const GDScriptParser::DictionaryNode *>(op->arguments[0]);
-					} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_DICTIONARY) {
-						dn = static_cast<const GDScriptParser::DictionaryNode *>(base.assigned_expression);
+					const CScriptParser::DictionaryNode *dn = nullptr;
+					if (op->arguments[0]->type == CScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const CScriptParser::DictionaryNode *>(op->arguments[0]);
+					} else if (base.assigned_expression && base.assigned_expression->type == CScriptParser::Node::TYPE_DICTIONARY) {
+						dn = static_cast<const CScriptParser::DictionaryNode *>(base.assigned_expression);
 					}
 
 					if (dn) {
 						for (int i = 0; i < dn->elements.size(); i++) {
-							GDScriptCompletionIdentifier key;
+							CScriptCompletionIdentifier key;
 							if (!_guess_expression_type(c, dn->elements[i].key, key)) {
 								continue;
 							}
@@ -1019,11 +1019,11 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 					// Look if it is an array node
 					if (!found && index.value.is_num()) {
 						int idx = index.value;
-						const GDScriptParser::ArrayNode *an = nullptr;
-						if (op->arguments[0]->type == GDScriptParser::Node::TYPE_ARRAY) {
-							an = static_cast<const GDScriptParser::ArrayNode *>(op->arguments[0]);
-						} else if (base.assigned_expression && base.assigned_expression->type == GDScriptParser::Node::TYPE_ARRAY) {
-							an = static_cast<const GDScriptParser::ArrayNode *>(base.assigned_expression);
+						const CScriptParser::ArrayNode *an = nullptr;
+						if (op->arguments[0]->type == CScriptParser::Node::TYPE_ARRAY) {
+							an = static_cast<const CScriptParser::ArrayNode *>(op->arguments[0]);
+						} else if (base.assigned_expression && base.assigned_expression->type == CScriptParser::Node::TYPE_ARRAY) {
+							an = static_cast<const CScriptParser::ArrayNode *>(base.assigned_expression);
 						}
 
 						if (an && idx >= 0 && an->elements.size() > idx) {
@@ -1037,7 +1037,7 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 					if (!found && (index.value.get_type() == Variant::STRING || index.value.get_type() == Variant::NODE_PATH)) {
 						StringName id = index.value;
 						found = _guess_identifier_type_from_base(c, base, id, r_type);
-					} else if (!found && index.type.kind == GDScriptParser::DataType::BUILTIN) {
+					} else if (!found && index.type.kind == CScriptParser::DataType::BUILTIN) {
 						Variant::CallError err;
 						Variant base_val = Variant::construct(base.type.builtin_type, nullptr, 0, err);
 						bool valid = false;
@@ -1058,34 +1058,34 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 
 					Variant::Operator vop = Variant::OP_MAX;
 					switch (op->op) {
-						case GDScriptParser::OperatorNode::OP_ADD:
+						case CScriptParser::OperatorNode::OP_ADD:
 							vop = Variant::OP_ADD;
 							break;
-						case GDScriptParser::OperatorNode::OP_SUB:
+						case CScriptParser::OperatorNode::OP_SUB:
 							vop = Variant::OP_SUBTRACT;
 							break;
-						case GDScriptParser::OperatorNode::OP_MUL:
+						case CScriptParser::OperatorNode::OP_MUL:
 							vop = Variant::OP_MULTIPLY;
 							break;
-						case GDScriptParser::OperatorNode::OP_DIV:
+						case CScriptParser::OperatorNode::OP_DIV:
 							vop = Variant::OP_DIVIDE;
 							break;
-						case GDScriptParser::OperatorNode::OP_MOD:
+						case CScriptParser::OperatorNode::OP_MOD:
 							vop = Variant::OP_MODULE;
 							break;
-						case GDScriptParser::OperatorNode::OP_SHIFT_LEFT:
+						case CScriptParser::OperatorNode::OP_SHIFT_LEFT:
 							vop = Variant::OP_SHIFT_LEFT;
 							break;
-						case GDScriptParser::OperatorNode::OP_SHIFT_RIGHT:
+						case CScriptParser::OperatorNode::OP_SHIFT_RIGHT:
 							vop = Variant::OP_SHIFT_RIGHT;
 							break;
-						case GDScriptParser::OperatorNode::OP_BIT_AND:
+						case CScriptParser::OperatorNode::OP_BIT_AND:
 							vop = Variant::OP_BIT_AND;
 							break;
-						case GDScriptParser::OperatorNode::OP_BIT_OR:
+						case CScriptParser::OperatorNode::OP_BIT_OR:
 							vop = Variant::OP_BIT_OR;
 							break;
-						case GDScriptParser::OperatorNode::OP_BIT_XOR:
+						case CScriptParser::OperatorNode::OP_BIT_XOR:
 							vop = Variant::OP_BIT_XOR;
 							break;
 						default: {
@@ -1096,11 +1096,11 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 						break;
 					}
 
-					GDScriptCompletionContext context = p_context;
+					CScriptCompletionContext context = p_context;
 					context.line = op->line;
 
-					GDScriptCompletionIdentifier p1;
-					GDScriptCompletionIdentifier p2;
+					CScriptCompletionIdentifier p1;
+					CScriptCompletionIdentifier p2;
 
 					if (!_guess_expression_type(context, op->arguments[0], p1)) {
 						found = false;
@@ -1149,7 +1149,7 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 	}
 
 	// It may have found a null, but that's never useful
-	if (found && r_type.type.has_type && r_type.type.kind == GDScriptParser::DataType::BUILTIN && r_type.type.builtin_type == Variant::NIL) {
+	if (found && r_type.type.has_type && r_type.type.kind == CScriptParser::DataType::BUILTIN && r_type.type.builtin_type == Variant::NIL) {
 		found = false;
 	}
 
@@ -1166,12 +1166,12 @@ static bool _guess_expression_type(GDScriptCompletionContext &p_context, const G
 	return found;
 }
 
-static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type) {
+static bool _guess_identifier_type(CScriptCompletionContext &p_context, const StringName &p_identifier, CScriptCompletionIdentifier &r_type) {
 	// Look in blocks first
-	const GDScriptParser::BlockNode *blk = p_context.block;
+	const CScriptParser::BlockNode *blk = p_context.block;
 	int last_assign_line = -1;
-	const GDScriptParser::Node *last_assigned_expression = nullptr;
-	GDScriptParser::DataType var_type;
+	const CScriptParser::Node *last_assigned_expression = nullptr;
+	CScriptParser::DataType var_type;
 	while (blk) {
 		if (blk->variables.has(p_identifier)) {
 			if (blk->variables[p_identifier]->line > p_context.line) {
@@ -1180,9 +1180,9 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 
 			var_type = blk->variables[p_identifier]->datatype;
 
-			if (!last_assigned_expression && blk->variables[p_identifier]->assign && blk->variables[p_identifier]->assign->type == GDScriptParser::Node::TYPE_OPERATOR) {
-				const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(blk->variables[p_identifier]->assign);
-				if (op->op == GDScriptParser::OperatorNode::OP_ASSIGN && op->arguments.size() >= 2) {
+			if (!last_assigned_expression && blk->variables[p_identifier]->assign && blk->variables[p_identifier]->assign->type == CScriptParser::Node::TYPE_OPERATOR) {
+				const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(blk->variables[p_identifier]->assign);
+				if (op->op == CScriptParser::OperatorNode::OP_ASSIGN && op->arguments.size() >= 2) {
 					last_assign_line = op->line;
 					last_assigned_expression = op->arguments[1];
 				}
@@ -1190,18 +1190,18 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 		}
 
 		for (int z = 0; z < blk->statements.size(); z++) {
-			const GDScriptParser::Node *expr = blk->statements[z];
-			if (expr->line > p_context.line || expr->type != GDScriptParser::Node::TYPE_OPERATOR) {
+			const CScriptParser::Node *expr = blk->statements[z];
+			if (expr->line > p_context.line || expr->type != CScriptParser::Node::TYPE_OPERATOR) {
 				continue;
 			}
 
-			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(expr);
-			if (op->op != GDScriptParser::OperatorNode::OP_ASSIGN || op->line < last_assign_line) {
+			const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(expr);
+			if (op->op != CScriptParser::OperatorNode::OP_ASSIGN || op->line < last_assign_line) {
 				continue;
 			}
 
-			if (op->arguments.size() >= 2 && op->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
-				const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0]);
+			if (op->arguments.size() >= 2 && op->arguments[0]->type == CScriptParser::Node::TYPE_IDENTIFIER) {
+				const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[0]);
 				if (id->name == p_identifier) {
 					last_assign_line = op->line;
 					last_assigned_expression = op->arguments[1];
@@ -1209,15 +1209,15 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 			}
 		}
 
-		if (blk->if_condition && blk->if_condition->type == GDScriptParser::Node::TYPE_OPERATOR && static_cast<const GDScriptParser::OperatorNode *>(blk->if_condition)->op == GDScriptParser::OperatorNode::OP_IS) {
+		if (blk->if_condition && blk->if_condition->type == CScriptParser::Node::TYPE_OPERATOR && static_cast<const CScriptParser::OperatorNode *>(blk->if_condition)->op == CScriptParser::OperatorNode::OP_IS) {
 			//is used, check if identifier is in there! this helps resolve in blocks that are (if (identifier is value)): which are very common..
 			//super dirty hack, but very useful
 			//credit: Zylann
 			//TODO: this could be hacked to detect ANDed conditions too..
-			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(blk->if_condition);
-			if (op->arguments[0]->type == GDScriptParser::Node::TYPE_IDENTIFIER && static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name == p_identifier) {
+			const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(blk->if_condition);
+			if (op->arguments[0]->type == CScriptParser::Node::TYPE_IDENTIFIER && static_cast<const CScriptParser::IdentifierNode *>(op->arguments[0])->name == p_identifier) {
 				//bingo
-				GDScriptCompletionContext c = p_context;
+				CScriptCompletionContext c = p_context;
 				c.line = op->line;
 				c.block = blk;
 				if (_guess_expression_type(p_context, op->arguments[1], r_type)) {
@@ -1235,7 +1235,7 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 	}
 
 	if (last_assigned_expression && last_assign_line != p_context.line) {
-		GDScriptCompletionContext c = p_context;
+		CScriptCompletionContext c = p_context;
 		c.line = last_assign_line;
 		r_type.assigned_expression = last_assigned_expression;
 		if (_guess_expression_type(c, last_assigned_expression, r_type)) {
@@ -1262,12 +1262,12 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 				int def_from = p_context.function->arguments.size() - p_context.function->default_values.size();
 				if (i >= def_from) {
 					int def_idx = i - def_from;
-					if (p_context.function->default_values[def_idx]->type == GDScriptParser::Node::TYPE_OPERATOR) {
-						const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_context.function->default_values[def_idx]);
+					if (p_context.function->default_values[def_idx]->type == CScriptParser::Node::TYPE_OPERATOR) {
+						const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(p_context.function->default_values[def_idx]);
 						if (op->arguments.size() < 2) {
 							return false;
 						}
-						GDScriptCompletionContext c = p_context;
+						CScriptCompletionContext c = p_context;
 						c.function = nullptr;
 						c.block = nullptr;
 						return _guess_expression_type(c, op->arguments[1], r_type);
@@ -1277,13 +1277,13 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 			}
 		}
 
-		GDScriptParser::DataType base_type = p_context._class->base_type;
+		CScriptParser::DataType base_type = p_context._class->base_type;
 		while (base_type.has_type) {
 			switch (base_type.kind) {
-				case GDScriptParser::DataType::GDSCRIPT: {
-					Ref<GDScript> gds = base_type.script_type;
+				case CScriptParser::DataType::CSCRIPT: {
+					Ref<CScript> gds = base_type.script_type;
 					if (gds.is_valid() && gds->has_method(p_context.function->name)) {
-						GDScriptFunction *func = gds->get_member_functions()[p_context.function->name];
+						CScriptFunction *func = gds->get_member_functions()[p_context.function->name];
 						if (func) {
 							for (int i = 0; i < func->get_argument_count(); i++) {
 								if (func->get_argument_name(i) == p_identifier) {
@@ -1292,20 +1292,20 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 								}
 							}
 						}
-						Ref<GDScript> base_gds = gds->get_base_script();
+						Ref<CScript> base_gds = gds->get_base_script();
 						if (base_gds.is_valid()) {
-							base_type.kind = GDScriptParser::DataType::GDSCRIPT;
+							base_type.kind = CScriptParser::DataType::CSCRIPT;
 							base_type.script_type = base_gds;
 						} else {
-							base_type.kind = GDScriptParser::DataType::NATIVE;
+							base_type.kind = CScriptParser::DataType::NATIVE;
 							base_type.native_type = gds->get_instance_base_type();
 						}
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = gds->get_instance_base_type();
 					}
 				} break;
-				case GDScriptParser::DataType::NATIVE: {
+				case CScriptParser::DataType::NATIVE: {
 					List<MethodInfo> methods;
 					ClassDB::get_method_list(base_type.native_type, &methods);
 					ClassDB::get_virtual_methods(base_type.native_type, &methods);
@@ -1332,11 +1332,11 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 
 	// Check current class (including inheritance)
 	if (p_context._class) {
-		GDScriptCompletionIdentifier context_base;
+		CScriptCompletionIdentifier context_base;
 		context_base.value = p_context.base;
 		context_base.type.has_type = true;
-		context_base.type.kind = GDScriptParser::DataType::CLASS;
-		context_base.type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+		context_base.type.kind = CScriptParser::DataType::CLASS;
+		context_base.type.class_type = const_cast<CScriptParser::ClassNode *>(p_context._class);
 		context_base.type.is_meta_type = p_context.function && p_context.function->_static;
 
 		if (_guess_identifier_type_from_base(p_context, context_base, p_identifier, r_type)) {
@@ -1370,52 +1370,52 @@ static bool _guess_identifier_type(GDScriptCompletionContext &p_context, const S
 
 		if (ClassDB::class_exists(target_id)) {
 			r_type.type.has_type = true;
-			r_type.type.kind = GDScriptParser::DataType::NATIVE;
+			r_type.type.kind = CScriptParser::DataType::NATIVE;
 			r_type.type.native_type = target_id;
 			if (Engine::get_singleton()->has_singleton(target_id)) {
 				r_type.type.is_meta_type = false;
 				r_type.value = Engine::get_singleton()->get_singleton_object(target_id);
 			} else {
 				r_type.type.is_meta_type = true;
-				const Map<StringName, int>::Element *target_elem = GDScriptLanguage::get_singleton()->get_global_map().find(target_id);
-				// Check because classes like EditorNode are in ClassDB by now, but unknown to GDScript
+				const Map<StringName, int>::Element *target_elem = CScriptLanguage::get_singleton()->get_global_map().find(target_id);
+				// Check because classes like EditorNode are in ClassDB by now, but unknown to CScript
 				if (!target_elem) {
 					return false;
 				}
 				int idx = target_elem->get();
-				r_type.value = GDScriptLanguage::get_singleton()->get_global_array()[idx];
+				r_type.value = CScriptLanguage::get_singleton()->get_global_array()[idx];
 			}
 			return true;
 		}
 	}
 
 	// Check autoload singletons
-	if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
-		r_type = _type_from_variant(GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier]);
+	if (CScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
+		r_type = _type_from_variant(CScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier]);
 		return true;
 	}
 
 	return false;
 }
 
-static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_identifier, GDScriptCompletionIdentifier &r_type) {
-	GDScriptParser::DataType base_type = p_base.type;
+static bool _guess_identifier_type_from_base(CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, const StringName &p_identifier, CScriptCompletionIdentifier &r_type) {
+	CScriptParser::DataType base_type = p_base.type;
 	bool _static = base_type.is_meta_type;
 	while (base_type.has_type) {
 		switch (base_type.kind) {
-			case GDScriptParser::DataType::CLASS: {
+			case CScriptParser::DataType::CLASS: {
 				if (base_type.class_type->constant_expressions.has(p_identifier)) {
-					GDScriptParser::ClassNode::Constant c = base_type.class_type->constant_expressions[p_identifier];
+					CScriptParser::ClassNode::Constant c = base_type.class_type->constant_expressions[p_identifier];
 					r_type.type = c.type;
-					if (c.expression->type == GDScriptParser::Node::TYPE_CONSTANT) {
-						r_type.value = static_cast<const GDScriptParser::ConstantNode *>(c.expression)->value;
+					if (c.expression->type == CScriptParser::Node::TYPE_CONSTANT) {
+						r_type.value = static_cast<const CScriptParser::ConstantNode *>(c.expression)->value;
 					}
 					return true;
 				}
 
 				if (!_static) {
 					for (int i = 0; i < base_type.class_type->variables.size(); i++) {
-						GDScriptParser::ClassNode::Member m = base_type.class_type->variables[i];
+						CScriptParser::ClassNode::Member m = base_type.class_type->variables[i];
 						if (m.identifier == p_identifier) {
 							if (m.expression) {
 								if (p_context.line == m.expression->line) {
@@ -1440,8 +1440,8 @@ static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_contex
 				}
 				base_type = base_type.class_type->base_type;
 			} break;
-			case GDScriptParser::DataType::GDSCRIPT: {
-				Ref<GDScript> gds = base_type.script_type;
+			case CScriptParser::DataType::CSCRIPT: {
+				Ref<CScript> gds = base_type.script_type;
 				if (gds.is_valid()) {
 					if (gds->get_constants().has(p_identifier)) {
 						r_type = _type_from_variant(gds->get_constants()[p_identifier]);
@@ -1454,18 +1454,18 @@ static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_contex
 							return true;
 						}
 					}
-					Ref<GDScript> parent = gds->get_base_script();
+					Ref<CScript> parent = gds->get_base_script();
 					if (parent.is_valid()) {
 						base_type.script_type = parent;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = gds->get_instance_base_type();
 					}
 				} else {
 					return false;
 				}
 			} break;
-			case GDScriptParser::DataType::SCRIPT: {
+			case CScriptParser::DataType::SCRIPT: {
 				Ref<Script> scr = base_type.script_type;
 				if (scr.is_valid()) {
 					Map<StringName, Variant> constants;
@@ -1490,14 +1490,14 @@ static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_contex
 					if (parent.is_valid()) {
 						base_type.script_type = parent;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = scr->get_instance_base_type();
 					}
 				} else {
 					return false;
 				}
 			} break;
-			case GDScriptParser::DataType::NATIVE: {
+			case CScriptParser::DataType::NATIVE: {
 				StringName class_name = base_type.native_type;
 				if (!ClassDB::class_exists(class_name)) {
 					class_name = String("_") + class_name;
@@ -1535,7 +1535,7 @@ static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_contex
 				}
 				return false;
 			} break;
-			case GDScriptParser::DataType::BUILTIN: {
+			case CScriptParser::DataType::BUILTIN: {
 				Variant::CallError err;
 				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
 
@@ -1561,7 +1561,7 @@ static bool _guess_identifier_type_from_base(GDScriptCompletionContext &p_contex
 	return false;
 }
 
-static bool _find_last_return_in_block(const GDScriptCompletionContext &p_context, int &r_last_return_line, const GDScriptParser::Node **r_last_returned_value) {
+static bool _find_last_return_in_block(const CScriptCompletionContext &p_context, int &r_last_return_line, const CScriptParser::Node **r_last_returned_value) {
 	if (!p_context.block) {
 		return false;
 	}
@@ -1570,12 +1570,12 @@ static bool _find_last_return_in_block(const GDScriptCompletionContext &p_contex
 		if (p_context.block->statements[i]->line < r_last_return_line) {
 			continue;
 		}
-		if (p_context.block->statements[i]->type != GDScriptParser::Node::TYPE_CONTROL_FLOW) {
+		if (p_context.block->statements[i]->type != CScriptParser::Node::TYPE_CONTROL_FLOW) {
 			continue;
 		}
 
-		const GDScriptParser::ControlFlowNode *cf = static_cast<const GDScriptParser::ControlFlowNode *>(p_context.block->statements[i]);
-		if (cf->cf_type == GDScriptParser::ControlFlowNode::CF_RETURN && cf->arguments.size() > 0) {
+		const CScriptParser::ControlFlowNode *cf = static_cast<const CScriptParser::ControlFlowNode *>(p_context.block->statements[i]);
+		if (cf->cf_type == CScriptParser::ControlFlowNode::CF_RETURN && cf->arguments.size() > 0) {
 			if (cf->line > r_last_return_line) {
 				r_last_return_line = cf->line;
 				*r_last_returned_value = cf->arguments[0];
@@ -1585,7 +1585,7 @@ static bool _find_last_return_in_block(const GDScriptCompletionContext &p_contex
 
 	// Recurse into subblocks
 	for (int i = 0; i < p_context.block->sub_blocks.size(); i++) {
-		GDScriptCompletionContext c = p_context;
+		CScriptCompletionContext c = p_context;
 		c.block = p_context.block->sub_blocks[i];
 		_find_last_return_in_block(c, r_last_return_line, r_last_returned_value);
 	}
@@ -1593,8 +1593,8 @@ static bool _find_last_return_in_block(const GDScriptCompletionContext &p_contex
 	return false;
 }
 
-static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, GDScriptCompletionIdentifier &r_type) {
-	GDScriptParser::DataType base_type = p_base.type;
+static bool _guess_method_return_type_from_base(CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, const StringName &p_method, CScriptCompletionIdentifier &r_type) {
+	CScriptParser::DataType base_type = p_base.type;
 	bool _static = base_type.is_meta_type;
 
 	if (_static && p_method == "new") {
@@ -1606,7 +1606,7 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 
 	while (base_type.has_type) {
 		switch (base_type.kind) {
-			case GDScriptParser::DataType::CLASS: {
+			case CScriptParser::DataType::CLASS: {
 				if (!base_type.class_type) {
 					base_type.has_type = false;
 					break;
@@ -1615,8 +1615,8 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 				for (int i = 0; i < base_type.class_type->static_functions.size(); i++) {
 					if (base_type.class_type->static_functions[i]->name == p_method) {
 						int last_return_line = -1;
-						const GDScriptParser::Node *last_returned_value = nullptr;
-						GDScriptCompletionContext c = p_context;
+						const CScriptParser::Node *last_returned_value = nullptr;
+						CScriptCompletionContext c = p_context;
 						c._class = base_type.class_type;
 						c.function = base_type.class_type->static_functions[i];
 						c.block = c.function->body;
@@ -1632,8 +1632,8 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 					for (int i = 0; i < base_type.class_type->functions.size(); i++) {
 						if (base_type.class_type->functions[i]->name == p_method) {
 							int last_return_line = -1;
-							const GDScriptParser::Node *last_returned_value = nullptr;
-							GDScriptCompletionContext c = p_context;
+							const CScriptParser::Node *last_returned_value = nullptr;
+							CScriptCompletionContext c = p_context;
 							c._class = base_type.class_type;
 							c.function = base_type.class_type->functions[i];
 							c.block = c.function->body;
@@ -1649,25 +1649,25 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 
 				base_type = base_type.class_type->base_type;
 			} break;
-			case GDScriptParser::DataType::GDSCRIPT: {
-				Ref<GDScript> gds = base_type.script_type;
+			case CScriptParser::DataType::CSCRIPT: {
+				Ref<CScript> gds = base_type.script_type;
 				if (gds.is_valid()) {
 					if (gds->get_member_functions().has(p_method)) {
 						r_type = _type_from_gdtype(gds->get_member_functions()[p_method]->get_return_type());
 						return true;
 					}
-					Ref<GDScript> base_script = gds->get_base_script();
+					Ref<CScript> base_script = gds->get_base_script();
 					if (base_script.is_valid()) {
 						base_type.script_type = base_script;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = gds->get_instance_base_type();
 					}
 				} else {
 					return false;
 				}
 			} break;
-			case GDScriptParser::DataType::SCRIPT: {
+			case CScriptParser::DataType::SCRIPT: {
 				Ref<Script> scr = base_type.script_type;
 				if (scr.is_valid()) {
 					List<MethodInfo> methods;
@@ -1683,14 +1683,14 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 					if (base_script.is_valid()) {
 						base_type.script_type = base_script;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = scr->get_instance_base_type();
 					}
 				} else {
 					return false;
 				}
 			} break;
-			case GDScriptParser::DataType::NATIVE: {
+			case CScriptParser::DataType::NATIVE: {
 				StringName native = base_type.native_type;
 				if (!ClassDB::class_exists(native)) {
 					native = String("_") + native;
@@ -1705,7 +1705,7 @@ static bool _guess_method_return_type_from_base(GDScriptCompletionContext &p_con
 				}
 				return false;
 			} break;
-			case GDScriptParser::DataType::BUILTIN: {
+			case CScriptParser::DataType::BUILTIN: {
 				Variant::CallError err;
 				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
 				if (err.error != Variant::CallError::CALL_OK) {
@@ -1776,7 +1776,7 @@ static String _make_arguments_hint(const MethodInfo &p_info, int p_arg_idx) {
 	return arghint;
 }
 
-static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_function, int p_arg_idx) {
+static String _make_arguments_hint(const CScriptParser::FunctionNode *p_function, int p_arg_idx) {
 	String arghint = p_function->return_type.to_string() + " " + p_function->name.operator String() + "(";
 
 	int def_args = p_function->arguments.size() - p_function->default_values.size();
@@ -1792,15 +1792,15 @@ static String _make_arguments_hint(const GDScriptParser::FunctionNode *p_functio
 
 		if (i - def_args >= 0) {
 			String def_val = "<unknown>";
-			if (p_function->default_values[i - def_args] && p_function->default_values[i - def_args]->type == GDScriptParser::Node::TYPE_OPERATOR) {
-				const GDScriptParser::OperatorNode *assign = static_cast<const GDScriptParser::OperatorNode *>(p_function->default_values[i - def_args]);
+			if (p_function->default_values[i - def_args] && p_function->default_values[i - def_args]->type == CScriptParser::Node::TYPE_OPERATOR) {
+				const CScriptParser::OperatorNode *assign = static_cast<const CScriptParser::OperatorNode *>(p_function->default_values[i - def_args]);
 
 				if (assign->arguments.size() >= 2) {
-					if (assign->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT) {
-						const GDScriptParser::ConstantNode *cn = static_cast<const GDScriptParser::ConstantNode *>(assign->arguments[1]);
+					if (assign->arguments[1]->type == CScriptParser::Node::TYPE_CONSTANT) {
+						const CScriptParser::ConstantNode *cn = static_cast<const CScriptParser::ConstantNode *>(assign->arguments[1]);
 						def_val = cn->value.get_construct_string();
-					} else if (assign->arguments[1]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
-						const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(assign->arguments[1]);
+					} else if (assign->arguments[1]->type == CScriptParser::Node::TYPE_IDENTIFIER) {
+						const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(assign->arguments[1]);
 						def_val = id->name.operator String();
 					}
 				}
@@ -1845,23 +1845,23 @@ static void _find_enumeration_candidates(const String p_enum_hint, Map<String, S
 	}
 }
 
-static void _find_identifiers_in_block(const GDScriptCompletionContext &p_context, Map<String, ScriptCodeCompletionOption> &r_result) {
-	for (Map<StringName, GDScriptParser::LocalVarNode *>::Element *E = p_context.block->variables.front(); E; E = E->next()) {
+static void _find_identifiers_in_block(const CScriptCompletionContext &p_context, Map<String, ScriptCodeCompletionOption> &r_result) {
+	for (Map<StringName, CScriptParser::LocalVarNode *>::Element *E = p_context.block->variables.front(); E; E = E->next()) {
 		if (E->get()->line < p_context.line) {
 			ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_VARIABLE);
 			r_result.insert(option.display, option);
 		}
 	}
 	if (p_context.block->parent_block) {
-		GDScriptCompletionContext c = p_context;
+		CScriptCompletionContext c = p_context;
 		c.block = p_context.block->parent_block;
 		_find_identifiers_in_block(c, r_result);
 	}
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result);
+static void _find_identifiers_in_base(const CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result);
 
-static void _find_identifiers_in_class(const GDScriptCompletionContext &p_context, bool p_static, bool p_only_functions, bool p_parent_only, Map<String, ScriptCodeCompletionOption> &r_result) {
+static void _find_identifiers_in_class(const CScriptCompletionContext &p_context, bool p_static, bool p_only_functions, bool p_parent_only, Map<String, ScriptCodeCompletionOption> &r_result) {
 	if (!p_parent_only) {
 		if (!p_static && !p_only_functions) {
 			for (int i = 0; i < p_context._class->variables.size(); i++) {
@@ -1871,10 +1871,10 @@ static void _find_identifiers_in_class(const GDScriptCompletionContext &p_contex
 		}
 
 		if (!p_only_functions) {
-			for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = p_context._class->constant_expressions.front(); E; E = E->next()) {
+			for (Map<StringName, CScriptParser::ClassNode::Constant>::Element *E = p_context._class->constant_expressions.front(); E; E = E->next()) {
 				ScriptCodeCompletionOption option(E->key(), ScriptCodeCompletionOption::KIND_CONSTANT);
-				if (E->get().expression && E->get().expression->type == GDScriptParser::Node::TYPE_CONSTANT) {
-					GDScriptParser::ConstantNode *cnode = (GDScriptParser::ConstantNode *)E->get().expression;
+				if (E->get().expression && E->get().expression->type == CScriptParser::Node::TYPE_CONSTANT) {
+					CScriptParser::ConstantNode *cnode = (CScriptParser::ConstantNode *)E->get().expression;
 					if (cnode) {
 						option.default_value = cnode->value;
 					}
@@ -1911,23 +1911,23 @@ static void _find_identifiers_in_class(const GDScriptCompletionContext &p_contex
 	}
 
 	// Parents
-	GDScriptCompletionIdentifier base_type;
+	CScriptCompletionIdentifier base_type;
 	base_type.type = p_context._class->base_type;
 	base_type.type.is_meta_type = p_static;
 	base_type.value = p_context.base;
 
-	GDScriptCompletionContext c = p_context;
+	CScriptCompletionContext c = p_context;
 	c.block = nullptr;
 	c.function = nullptr;
 
 	_find_identifiers_in_base(c, base_type, p_only_functions, r_result);
 }
 
-static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
-	GDScriptParser::DataType base_type = p_base.type;
+static void _find_identifiers_in_base(const CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
+	CScriptParser::DataType base_type = p_base.type;
 	bool _static = base_type.is_meta_type;
 
-	if (_static && base_type.kind != GDScriptParser::DataType::BUILTIN) {
+	if (_static && base_type.kind != CScriptParser::DataType::BUILTIN) {
 		ScriptCodeCompletionOption option("new", ScriptCodeCompletionOption::KIND_FUNCTION);
 		option.insert_text += "(";
 		r_result.insert(option.display, option);
@@ -1935,16 +1935,16 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 
 	while (base_type.has_type) {
 		switch (base_type.kind) {
-			case GDScriptParser::DataType::CLASS: {
-				GDScriptCompletionContext c = p_context;
+			case CScriptParser::DataType::CLASS: {
+				CScriptCompletionContext c = p_context;
 				c._class = base_type.class_type;
 				c.block = nullptr;
 				c.function = nullptr;
 				_find_identifiers_in_class(c, _static, p_only_functions, false, r_result);
 				base_type = base_type.class_type->base_type;
 			} break;
-			case GDScriptParser::DataType::GDSCRIPT: {
-				Ref<GDScript> script = base_type.script_type;
+			case CScriptParser::DataType::CSCRIPT: {
+				Ref<CScript> script = base_type.script_type;
 				if (script.is_valid()) {
 					if (!_static && !p_only_functions) {
 						if (p_context.base && p_context.base->get_script_instance()) {
@@ -1966,7 +1966,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 							r_result.insert(option.display, option);
 						}
 					}
-					for (const Map<StringName, GDScriptFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) {
+					for (const Map<StringName, CScriptFunction *>::Element *E = script->get_member_functions().front(); E; E = E->next()) {
 						if (!_static || E->get()->is_static()) {
 							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_FUNCTION);
 							if (E->get()->get_argument_count()) {
@@ -1978,26 +1978,26 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 						}
 					}
 					if (!p_only_functions) {
-						for (const Map<StringName, Ref<GDScript>>::Element *E = script->get_subclasses().front(); E; E = E->next()) {
+						for (const Map<StringName, Ref<CScript>>::Element *E = script->get_subclasses().front(); E; E = E->next()) {
 							ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
 							r_result.insert(option.display, option);
 						}
 					}
-					base_type = GDScriptParser::DataType();
+					base_type = CScriptParser::DataType();
 					if (script->get_base().is_valid()) {
 						base_type.has_type = true;
-						base_type.kind = GDScriptParser::DataType::GDSCRIPT;
+						base_type.kind = CScriptParser::DataType::CSCRIPT;
 						base_type.script_type = script->get_base();
 					} else {
 						base_type.has_type = script->get_instance_base_type() != StringName();
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = script->get_instance_base_type();
 					}
 				} else {
 					return;
 				}
 			} break;
-			case GDScriptParser::DataType::SCRIPT: {
+			case CScriptParser::DataType::SCRIPT: {
 				Ref<Script> scr = base_type.script_type;
 				if (scr.is_valid()) {
 					if (!_static && !p_only_functions) {
@@ -2033,14 +2033,14 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 					if (base_script.is_valid()) {
 						base_type.script_type = base_script;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = scr->get_instance_base_type();
 					}
 				} else {
 					return;
 				}
 			} break;
-			case GDScriptParser::DataType::NATIVE: {
+			case CScriptParser::DataType::NATIVE: {
 				StringName type = base_type.native_type;
 				if (!ClassDB::class_exists(type)) {
 					type = String("_") + type;
@@ -2093,7 +2093,7 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 
 				return;
 			} break;
-			case GDScriptParser::DataType::BUILTIN: {
+			case CScriptParser::DataType::BUILTIN: {
 				Variant::CallError err;
 				Variant tmp = Variant::construct(base_type.builtin_type, nullptr, 0, err);
 				if (err.error != Variant::CallError::CALL_OK) {
@@ -2137,11 +2137,11 @@ static void _find_identifiers_in_base(const GDScriptCompletionContext &p_context
 	}
 }
 
-static void _find_identifiers(const GDScriptCompletionContext &p_context, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
-	const GDScriptParser::BlockNode *block = p_context.block;
+static void _find_identifiers(const CScriptCompletionContext &p_context, bool p_only_functions, Map<String, ScriptCodeCompletionOption> &r_result) {
+	const CScriptParser::BlockNode *block = p_context.block;
 
 	if (p_context.function) {
-		const GDScriptParser::FunctionNode *f = p_context.function;
+		const CScriptParser::FunctionNode *f = p_context.function;
 
 		for (int i = 0; i < f->arguments.size(); i++) {
 			ScriptCodeCompletionOption option(f->arguments[i].operator String(), ScriptCodeCompletionOption::KIND_PLAIN_TEXT);
@@ -2150,16 +2150,16 @@ static void _find_identifiers(const GDScriptCompletionContext &p_context, bool p
 	}
 
 	if (!p_only_functions && block) {
-		GDScriptCompletionContext c = p_context;
+		CScriptCompletionContext c = p_context;
 		c.block = block;
 		_find_identifiers_in_block(c, r_result);
 	}
 
-	const GDScriptParser::ClassNode *clss = p_context._class;
+	const CScriptParser::ClassNode *clss = p_context._class;
 	bool _static = p_context.function && p_context.function->_static;
 
 	while (clss) {
-		GDScriptCompletionContext c = p_context;
+		CScriptCompletionContext c = p_context;
 		c._class = clss;
 		c.block = nullptr;
 		c.function = nullptr;
@@ -2168,9 +2168,9 @@ static void _find_identifiers(const GDScriptCompletionContext &p_context, bool p
 		clss = clss->owner;
 	}
 
-	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
-		MethodInfo mi = GDScriptFunctions::get_info(GDScriptFunctions::Function(i));
-		ScriptCodeCompletionOption option(String(GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i))), ScriptCodeCompletionOption::KIND_FUNCTION);
+	for (int i = 0; i < CScriptFunctions::FUNC_MAX; i++) {
+		MethodInfo mi = CScriptFunctions::get_info(CScriptFunctions::Function(i));
+		ScriptCodeCompletionOption option(String(CScriptFunctions::get_func_name(CScriptFunctions::Function(i))), ScriptCodeCompletionOption::KIND_FUNCTION);
 		if (mi.arguments.size() || (mi.flags & METHOD_FLAG_VARARG)) {
 			option.insert_text += "(";
 		} else {
@@ -2231,15 +2231,15 @@ static void _find_identifiers(const GDScriptCompletionContext &p_context, bool p
 	}
 
 	// Native classes
-	for (const Map<StringName, int>::Element *E = GDScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
+	for (const Map<StringName, int>::Element *E = CScriptLanguage::get_singleton()->get_global_map().front(); E; E = E->next()) {
 		ScriptCodeCompletionOption option(E->key().operator String(), ScriptCodeCompletionOption::KIND_CLASS);
 		r_result.insert(option.display, option);
 	}
 }
 
-static void _find_call_arguments(const GDScriptCompletionContext &p_context, const GDScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptCodeCompletionOption> &r_result, String &r_arghint) {
+static void _find_call_arguments(const CScriptCompletionContext &p_context, const CScriptCompletionIdentifier &p_base, const StringName &p_method, int p_argidx, bool p_static, Map<String, ScriptCodeCompletionOption> &r_result, String &r_arghint) {
 	Variant base = p_base.value;
-	GDScriptParser::DataType base_type = p_base.type;
+	CScriptParser::DataType base_type = p_base.type;
 
 	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
 
@@ -2247,7 +2247,7 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 
 	while (base_type.has_type) {
 		switch (base_type.kind) {
-			case GDScriptParser::DataType::CLASS: {
+			case CScriptParser::DataType::CLASS: {
 				for (int i = 0; i < base_type.class_type->static_functions.size(); i++) {
 					if (base_type.class_type->static_functions[i]->name == p_method) {
 						r_arghint = _make_arguments_hint(base_type.class_type->static_functions[i], p_argidx);
@@ -2271,8 +2271,8 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 
 				base_type = base_type.class_type->base_type;
 			} break;
-			case GDScriptParser::DataType::GDSCRIPT: {
-				Ref<GDScript> gds = base_type.script_type;
+			case CScriptParser::DataType::CSCRIPT: {
+				Ref<CScript> gds = base_type.script_type;
 				if (gds.is_valid()) {
 					if (IS_METHOD_SIGNAL(p_method) && p_argidx == 0) {
 						List<MethodInfo> signals;
@@ -2283,18 +2283,18 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 							r_result.insert(option.display, option);
 						}
 					}
-					Ref<GDScript> base_script = gds->get_base_script();
+					Ref<CScript> base_script = gds->get_base_script();
 					if (base_script.is_valid()) {
 						base_type.script_type = base_script;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = gds->get_instance_base_type();
 					}
 				} else {
 					return;
 				}
 			} break;
-			case GDScriptParser::DataType::NATIVE: {
+			case CScriptParser::DataType::NATIVE: {
 				StringName class_name = base_type.native_type;
 				if (!ClassDB::class_exists(class_name)) {
 					class_name = String("_") + class_name;
@@ -2382,7 +2382,7 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 
 				base_type.has_type = false;
 			} break;
-			case GDScriptParser::DataType::BUILTIN: {
+			case CScriptParser::DataType::BUILTIN: {
 				if (base.get_type() == Variant::NIL) {
 					Variant::CallError err;
 					base = Variant::construct(base_type.builtin_type, nullptr, 0, err);
@@ -2409,22 +2409,22 @@ static void _find_call_arguments(const GDScriptCompletionContext &p_context, con
 	}
 }
 
-static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDScriptParser::Node *p_node, int p_argidx, Map<String, ScriptCodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
+static void _find_call_arguments(CScriptCompletionContext &p_context, const CScriptParser::Node *p_node, int p_argidx, Map<String, ScriptCodeCompletionOption> &r_result, bool &r_forced, String &r_arghint) {
 	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
 
-	if (!p_node || p_node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+	if (!p_node || p_node->type != CScriptParser::Node::TYPE_OPERATOR) {
 		return;
 	}
 
 	Variant base;
-	GDScriptParser::DataType base_type;
+	CScriptParser::DataType base_type;
 	StringName function;
 	bool _static = false;
-	const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(p_node);
+	const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(p_node);
 
-	GDScriptCompletionIdentifier connect_base;
+	CScriptCompletionIdentifier connect_base;
 
-	if (op->op != GDScriptParser::OperatorNode::OP_CALL && op->op != GDScriptParser::OperatorNode::OP_PARENT_CALL) {
+	if (op->op != CScriptParser::OperatorNode::OP_CALL && op->op != CScriptParser::OperatorNode::OP_PARENT_CALL) {
 		return;
 	}
 
@@ -2432,11 +2432,11 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 		return;
 	}
 
-	if (op->op == GDScriptParser::OperatorNode::OP_CALL) {
-		if (op->arguments[0]->type == GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
+	if (op->op == CScriptParser::OperatorNode::OP_CALL) {
+		if (op->arguments[0]->type == CScriptParser::Node::TYPE_BUILT_IN_FUNCTION) {
 			// Complete built-in function
-			const GDScriptParser::BuiltInFunctionNode *fn = static_cast<const GDScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
-			MethodInfo mi = GDScriptFunctions::get_info(fn->function);
+			const CScriptParser::BuiltInFunctionNode *fn = static_cast<const CScriptParser::BuiltInFunctionNode *>(op->arguments[0]);
+			MethodInfo mi = CScriptFunctions::get_info(fn->function);
 
 			if ((mi.name == "load" || mi.name == "preload") && bool(EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths"))) {
 				_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), r_result);
@@ -2445,9 +2445,9 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 			r_arghint = _make_arguments_hint(mi, p_argidx);
 			return;
 
-		} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_TYPE) {
+		} else if (op->arguments[0]->type == CScriptParser::Node::TYPE_TYPE) {
 			// Complete constructor
-			const GDScriptParser::TypeNode *tn = static_cast<const GDScriptParser::TypeNode *>(op->arguments[0]);
+			const CScriptParser::TypeNode *tn = static_cast<const CScriptParser::TypeNode *>(op->arguments[0]);
 
 			List<MethodInfo> constructors;
 			Variant::get_constructor_list(tn->vtype, &constructors);
@@ -2464,18 +2464,18 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 				i++;
 			}
 			return;
-		} else if (op->arguments[0]->type == GDScriptParser::Node::TYPE_SELF) {
-			if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+		} else if (op->arguments[0]->type == CScriptParser::Node::TYPE_SELF) {
+			if (op->arguments.size() < 2 || op->arguments[1]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 				return;
 			}
 
 			base = p_context.base;
 
-			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+			const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[1]);
 			function = id->name;
 			base_type.has_type = true;
-			base_type.kind = GDScriptParser::DataType::CLASS;
-			base_type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+			base_type.kind = CScriptParser::DataType::CLASS;
+			base_type.class_type = const_cast<CScriptParser::ClassNode *>(p_context._class);
 			_static = p_context.function && p_context.function->_static;
 
 			if (function == "connect" && op->arguments.size() >= 4) {
@@ -2483,13 +2483,13 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 			}
 
 		} else {
-			if (op->arguments.size() < 2 || op->arguments[1]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+			if (op->arguments.size() < 2 || op->arguments[1]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 				return;
 			}
-			const GDScriptParser::IdentifierNode *id = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[1]);
+			const CScriptParser::IdentifierNode *id = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[1]);
 			function = id->name;
 
-			GDScriptCompletionIdentifier ci;
+			CScriptCompletionIdentifier ci;
 			if (_guess_expression_type(p_context, op->arguments[0], ci)) {
 				base_type = ci.type;
 				base = ci.value;
@@ -2503,23 +2503,23 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 			}
 		}
 	} else {
-		if (!p_context._class || op->arguments.size() < 1 || op->arguments[0]->type != GDScriptParser::Node::TYPE_IDENTIFIER) {
+		if (!p_context._class || op->arguments.size() < 1 || op->arguments[0]->type != CScriptParser::Node::TYPE_IDENTIFIER) {
 			return;
 		}
 		base_type.has_type = true;
-		base_type.kind = GDScriptParser::DataType::CLASS;
-		base_type.class_type = const_cast<GDScriptParser::ClassNode *>(p_context._class);
+		base_type.kind = CScriptParser::DataType::CLASS;
+		base_type.class_type = const_cast<CScriptParser::ClassNode *>(p_context._class);
 		base_type.is_meta_type = p_context.function && p_context.function->_static;
 		base = p_context.base;
 
-		function = static_cast<const GDScriptParser::IdentifierNode *>(op->arguments[0])->name;
+		function = static_cast<const CScriptParser::IdentifierNode *>(op->arguments[0])->name;
 
 		if (function == "connect" && op->arguments.size() >= 4) {
 			_guess_expression_type(p_context, op->arguments[3], connect_base);
 		}
 	}
 
-	GDScriptCompletionIdentifier ci;
+	CScriptCompletionIdentifier ci;
 	ci.type = base_type;
 	ci.value = base;
 	_find_call_arguments(p_context, ci, function, p_argidx, _static, r_result, r_arghint);
@@ -2537,15 +2537,15 @@ static void _find_call_arguments(GDScriptCompletionContext &p_context, const GDS
 	r_forced = r_result.size() > 0;
 }
 
-Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
+Error CScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
 	const String quote_style = EDITOR_DEF("text_editor/completion/use_single_quotes", false) ? "'" : "\"";
 
-	GDScriptParser parser;
+	CScriptParser parser;
 
 	parser.parse(p_code, p_path.get_base_dir(), false, p_path, true);
 	r_forced = false;
 	Map<String, ScriptCodeCompletionOption> options;
-	GDScriptCompletionContext context;
+	CScriptCompletionContext context;
 	context._class = parser.get_completion_class();
 	context.block = parser.get_completion_block();
 	context.function = parser.get_completion_function();
@@ -2559,9 +2559,9 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 	bool is_function = false;
 
 	switch (parser.get_completion_type()) {
-		case GDScriptParser::COMPLETION_NONE: {
+		case CScriptParser::COMPLETION_NONE: {
 		} break;
-		case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
+		case CScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
 			List<StringName> constants;
 			Variant::get_constants_for_type(parser.get_completion_built_in_constant(), &constants);
 			for (List<StringName>::Element *E = constants.front(); E; E = E->next()) {
@@ -2574,17 +2574,17 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				options.insert(option.display, option);
 			}
 		} break;
-		case GDScriptParser::COMPLETION_PARENT_FUNCTION: {
+		case CScriptParser::COMPLETION_PARENT_FUNCTION: {
 			_find_identifiers_in_class(context, !context.function || context.function->_static, true, true, options);
 		} break;
-		case GDScriptParser::COMPLETION_FUNCTION: {
+		case CScriptParser::COMPLETION_FUNCTION: {
 			is_function = true;
 			FALLTHROUGH;
 		}
-		case GDScriptParser::COMPLETION_IDENTIFIER: {
+		case CScriptParser::COMPLETION_IDENTIFIER: {
 			_find_identifiers(context, is_function, options);
 		} break;
-		case GDScriptParser::COMPLETION_EXTENDS: {
+		case CScriptParser::COMPLETION_EXTENDS: {
 			// Native classes.
 			List<StringName> class_list;
 			ClassDB::get_class_list(&class_list);
@@ -2593,10 +2593,10 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				options.insert(option.display, option);
 			}
 
-			// GDScript classes.
+			// CScript classes.
 			if (EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths")) {
 				for (int i = 0; i < ScriptServer::get_language_count(); i++) {
-					if (ScriptServer::get_language(i)->get_name() == "GDScript") {
+					if (ScriptServer::get_language(i)->get_name() == "CScript") {
 						List<String> extensions;
 						ScriptServer::get_language(i)->get_recognized_extensions(&extensions);
 						for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
@@ -2615,7 +2615,7 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				options.insert(option.display, option);
 			}
 		} break;
-		case GDScriptParser::COMPLETION_GET_NODE: {
+		case CScriptParser::COMPLETION_GET_NODE: {
 			if (p_owner) {
 				List<String> opts;
 				p_owner->get_argument_options("get_node", 0, &opts);
@@ -2650,30 +2650,30 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				}
 			}
 		} break;
-		case GDScriptParser::COMPLETION_METHOD: {
+		case CScriptParser::COMPLETION_METHOD: {
 			is_function = true;
 			FALLTHROUGH;
 		}
-		case GDScriptParser::COMPLETION_INDEX: {
-			const GDScriptParser::Node *node = parser.get_completion_node();
-			if (node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+		case CScriptParser::COMPLETION_INDEX: {
+			const CScriptParser::Node *node = parser.get_completion_node();
+			if (node->type != CScriptParser::Node::TYPE_OPERATOR) {
 				break;
 			}
-			const GDScriptParser::OperatorNode *op = static_cast<const GDScriptParser::OperatorNode *>(node);
+			const CScriptParser::OperatorNode *op = static_cast<const CScriptParser::OperatorNode *>(node);
 			if (op->arguments.size() < 1) {
 				break;
 			}
 
-			GDScriptCompletionIdentifier base;
+			CScriptCompletionIdentifier base;
 			if (!_guess_expression_type(context, op->arguments[0], base)) {
 				break;
 			}
 
-			GDScriptCompletionContext c = context;
+			CScriptCompletionContext c = context;
 			c.function = nullptr;
 			c.block = nullptr;
 			c.base = base.value.get_type() == Variant::OBJECT ? base.value.operator Object *() : nullptr;
-			if (base.type.kind == GDScriptParser::DataType::CLASS) {
+			if (base.type.kind == CScriptParser::DataType::CLASS) {
 				c._class = base.type.class_type;
 			} else {
 				c._class = nullptr;
@@ -2681,25 +2681,25 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 
 			_find_identifiers_in_base(c, base, is_function, options);
 		} break;
-		case GDScriptParser::COMPLETION_CALL_ARGUMENTS: {
+		case CScriptParser::COMPLETION_CALL_ARGUMENTS: {
 			_find_call_arguments(context, parser.get_completion_node(), parser.get_completion_argument_index(), options, r_forced, r_call_hint);
 		} break;
-		case GDScriptParser::COMPLETION_VIRTUAL_FUNC: {
-			GDScriptParser::DataType native_type = context._class->base_type;
-			while (native_type.has_type && native_type.kind != GDScriptParser::DataType::NATIVE) {
+		case CScriptParser::COMPLETION_VIRTUAL_FUNC: {
+			CScriptParser::DataType native_type = context._class->base_type;
+			while (native_type.has_type && native_type.kind != CScriptParser::DataType::NATIVE) {
 				switch (native_type.kind) {
-					case GDScriptParser::DataType::CLASS: {
+					case CScriptParser::DataType::CLASS: {
 						native_type = native_type.class_type->base_type;
 					} break;
-					case GDScriptParser::DataType::GDSCRIPT: {
-						Ref<GDScript> gds = native_type.script_type;
+					case CScriptParser::DataType::CSCRIPT: {
+						Ref<CScript> gds = native_type.script_type;
 						if (gds.is_valid()) {
-							Ref<GDScript> base = gds->get_base_script();
+							Ref<CScript> base = gds->get_base_script();
 							if (base.is_valid()) {
 								native_type.script_type = base;
 							} else {
 								native_type.native_type = gds->get_instance_base_type();
-								native_type.kind = GDScriptParser::DataType::NATIVE;
+								native_type.kind = CScriptParser::DataType::NATIVE;
 							}
 						} else {
 							native_type.has_type = false;
@@ -2772,20 +2772,20 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				options.insert(option.display, option);
 			}
 		} break;
-		case GDScriptParser::COMPLETION_YIELD: {
-			const GDScriptParser::Node *node = parser.get_completion_node();
+		case CScriptParser::COMPLETION_YIELD: {
+			const CScriptParser::Node *node = parser.get_completion_node();
 
-			GDScriptCompletionContext c = context;
+			CScriptCompletionContext c = context;
 			c.line = node->line;
-			GDScriptCompletionIdentifier type;
+			CScriptCompletionIdentifier type;
 			if (!_guess_expression_type(c, node, type)) {
 				break;
 			}
 
-			GDScriptParser::DataType base_type = type.type;
+			CScriptParser::DataType base_type = type.type;
 			while (base_type.has_type) {
 				switch (base_type.kind) {
-					case GDScriptParser::DataType::CLASS: {
+					case CScriptParser::DataType::CLASS: {
 						for (int i = 0; i < base_type.class_type->_signals.size(); i++) {
 							ScriptCodeCompletionOption option(base_type.class_type->_signals[i].name.operator String(), ScriptCodeCompletionOption::KIND_SIGNAL);
 							option.insert_text = quote_style + option.display + quote_style;
@@ -2793,8 +2793,8 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 						}
 						base_type = base_type.class_type->base_type;
 					} break;
-					case GDScriptParser::DataType::SCRIPT:
-					case GDScriptParser::DataType::GDSCRIPT: {
+					case CScriptParser::DataType::SCRIPT:
+					case CScriptParser::DataType::CSCRIPT: {
 						Ref<Script> scr = base_type.script_type;
 						if (scr.is_valid()) {
 							List<MethodInfo> signals;
@@ -2807,14 +2807,14 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 							if (base_script.is_valid()) {
 								base_type.script_type = base_script;
 							} else {
-								base_type.kind = GDScriptParser::DataType::NATIVE;
+								base_type.kind = CScriptParser::DataType::NATIVE;
 								base_type.native_type = scr->get_instance_base_type();
 							}
 						} else {
 							base_type.has_type = false;
 						}
 					} break;
-					case GDScriptParser::DataType::NATIVE: {
+					case CScriptParser::DataType::NATIVE: {
 						base_type.has_type = false;
 
 						StringName class_name = base_type.native_type;
@@ -2838,14 +2838,14 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				}
 			}
 		} break;
-		case GDScriptParser::COMPLETION_RESOURCE_PATH: {
+		case CScriptParser::COMPLETION_RESOURCE_PATH: {
 			if (EditorSettings::get_singleton()->get("text_editor/completion/complete_file_paths")) {
 				_get_directory_contents(EditorFileSystem::get_singleton()->get_filesystem(), options);
 				r_forced = true;
 			}
 		} break;
-		case GDScriptParser::COMPLETION_ASSIGN: {
-			GDScriptCompletionIdentifier type;
+		case CScriptParser::COMPLETION_ASSIGN: {
+			CScriptCompletionIdentifier type;
 			if (!_guess_expression_type(context, parser.get_completion_node(), type)) {
 				break;
 			}
@@ -2855,12 +2855,12 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				r_forced = options.size() > 0;
 			}
 		} break;
-		case GDScriptParser::COMPLETION_TYPE_HINT: {
-			const GDScriptParser::ClassNode *clss = context._class;
+		case CScriptParser::COMPLETION_TYPE_HINT: {
+			const CScriptParser::ClassNode *clss = context._class;
 			while (clss) {
-				for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = clss->constant_expressions.front(); E; E = E->next()) {
-					GDScriptCompletionIdentifier constant;
-					GDScriptCompletionContext c = context;
+				for (Map<StringName, CScriptParser::ClassNode::Constant>::Element *E = clss->constant_expressions.front(); E; E = E->next()) {
+					CScriptCompletionIdentifier constant;
+					CScriptCompletionContext c = context;
 					c.function = nullptr;
 					c.block = nullptr;
 					c.line = E->value().expression->line;
@@ -2922,14 +2922,14 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 			}
 			r_forced = true;
 		} break;
-		case GDScriptParser::COMPLETION_TYPE_HINT_INDEX: {
-			GDScriptCompletionIdentifier base;
+		case CScriptParser::COMPLETION_TYPE_HINT_INDEX: {
+			CScriptCompletionIdentifier base;
 			String index = parser.get_completion_cursor().operator String();
 			if (!_guess_identifier_type(context, index.get_slice(".", 0), base)) {
 				break;
 			}
 
-			GDScriptCompletionContext c = context;
+			CScriptCompletionContext c = context;
 			c._class = nullptr;
 			c.function = nullptr;
 			c.block = nullptr;
@@ -2938,7 +2938,7 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 			while (index.find(".") != -1) {
 				String id = index.get_slice(".", 0);
 
-				GDScriptCompletionIdentifier sub_base;
+				CScriptCompletionIdentifier sub_base;
 				if (!_guess_identifier_type_from_base(c, base, id, sub_base)) {
 					finding = false;
 					break;
@@ -2951,14 +2951,14 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 				break;
 			}
 
-			GDScriptParser::DataType base_type = base.type;
+			CScriptParser::DataType base_type = base.type;
 			while (base_type.has_type) {
 				switch (base_type.kind) {
-					case GDScriptParser::DataType::CLASS: {
+					case CScriptParser::DataType::CLASS: {
 						if (base_type.class_type) {
-							for (Map<StringName, GDScriptParser::ClassNode::Constant>::Element *E = base_type.class_type->constant_expressions.front(); E; E = E->next()) {
-								GDScriptCompletionIdentifier constant;
-								GDScriptCompletionContext c2 = context;
+							for (Map<StringName, CScriptParser::ClassNode::Constant>::Element *E = base_type.class_type->constant_expressions.front(); E; E = E->next()) {
+								CScriptCompletionIdentifier constant;
+								CScriptCompletionContext c2 = context;
 								c2._class = base_type.class_type;
 								c2.function = nullptr;
 								c2.block = nullptr;
@@ -2982,8 +2982,8 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 							base_type.has_type = false;
 						}
 					} break;
-					case GDScriptParser::DataType::SCRIPT:
-					case GDScriptParser::DataType::GDSCRIPT: {
+					case CScriptParser::DataType::SCRIPT:
+					case CScriptParser::DataType::CSCRIPT: {
 						Ref<Script> scr = base_type.script_type;
 						if (scr.is_valid()) {
 							Map<StringName, Variant> constants;
@@ -3023,7 +3023,7 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 
 #else
 
-Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
+Error CScriptLanguage::complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_forced, String &r_call_hint) {
 	return OK;
 }
 
@@ -3031,7 +3031,7 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_path
 
 //////// END COMPLETION //////////
 
-String GDScriptLanguage::_get_indentation() const {
+String CScriptLanguage::_get_indentation() const {
 #ifdef TOOLS_ENABLED
 	if (Engine::get_singleton()->is_editor_hint()) {
 		bool use_space_indentation = EDITOR_DEF("text_editor/indent/type", false);
@@ -3050,7 +3050,7 @@ String GDScriptLanguage::_get_indentation() const {
 	return "\t";
 }
 
-void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
+void CScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {
 	String indent = _get_indentation();
 
 	Vector<String> lines = p_code.split("\n");
@@ -3114,12 +3114,12 @@ void GDScriptLanguage::auto_indent_code(String &p_code, int p_from_line, int p_t
 
 #ifdef TOOLS_ENABLED
 
-static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, const String &p_symbol, bool p_is_function, GDScriptLanguage::LookupResult &r_result) {
-	GDScriptParser::DataType base_type = p_base;
+static Error _lookup_symbol_from_base(const CScriptParser::DataType &p_base, const String &p_symbol, bool p_is_function, CScriptLanguage::LookupResult &r_result) {
+	CScriptParser::DataType base_type = p_base;
 
 	while (base_type.has_type) {
 		switch (base_type.kind) {
-			case GDScriptParser::DataType::CLASS: {
+			case CScriptParser::DataType::CLASS: {
 				if (base_type.class_type) {
 					if (p_is_function) {
 						for (int i = 0; i < base_type.class_type->functions.size(); i++) {
@@ -3162,8 +3162,8 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					base_type = base_type.class_type->base_type;
 				}
 			} break;
-			case GDScriptParser::DataType::SCRIPT:
-			case GDScriptParser::DataType::GDSCRIPT: {
+			case CScriptParser::DataType::SCRIPT:
+			case CScriptParser::DataType::CSCRIPT: {
 				Ref<Script> scr = base_type.script_type;
 				if (scr.is_valid()) {
 					int line = scr->get_member_line(p_symbol);
@@ -3177,14 +3177,14 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					if (base_script.is_valid()) {
 						base_type.script_type = base_script;
 					} else {
-						base_type.kind = GDScriptParser::DataType::NATIVE;
+						base_type.kind = CScriptParser::DataType::NATIVE;
 						base_type.native_type = scr->get_instance_base_type();
 					}
 				} else {
 					base_type.has_type = false;
 				}
 			} break;
-			case GDScriptParser::DataType::NATIVE: {
+			case CScriptParser::DataType::NATIVE: {
 				StringName class_name = base_type.native_type;
 				if (!ClassDB::class_exists(class_name)) {
 					class_name = String("_") + class_name;
@@ -3253,7 +3253,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 					base_type.has_type = false;
 				}
 			} break;
-			case GDScriptParser::DataType::BUILTIN: {
+			case CScriptParser::DataType::BUILTIN: {
 				base_type.has_type = false;
 
 				if (Variant::has_constant(base_type.builtin_type, p_symbol)) {
@@ -3301,7 +3301,7 @@ static Error _lookup_symbol_from_base(const GDScriptParser::DataType &p_base, co
 	return ERR_CANT_RESOLVE;
 }
 
-Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) {
+Error CScriptLanguage::lookup_code(const String &p_code, const String &p_symbol, const String &p_path, Object *p_owner, LookupResult &r_result) {
 	//before parsing, try the usual stuff
 	if (ClassDB::class_exists(p_symbol)) {
 		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
@@ -3327,19 +3327,19 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 
 	if ("PI" == p_symbol || "TAU" == p_symbol || "INF" == p_symbol || "NAN" == p_symbol) {
 		r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
-		r_result.class_name = "@GDScript";
+		r_result.class_name = "@CScript";
 		r_result.class_member = p_symbol;
 		return OK;
 	}
 
-	GDScriptParser parser;
+	CScriptParser parser;
 	parser.parse(p_code, p_path.get_base_dir(), false, p_path, true);
 
-	if (parser.get_completion_type() == GDScriptParser::COMPLETION_NONE) {
+	if (parser.get_completion_type() == CScriptParser::COMPLETION_NONE) {
 		return ERR_CANT_RESOLVE;
 	}
 
-	GDScriptCompletionContext context;
+	CScriptCompletionContext context;
 	context._class = parser.get_completion_class();
 	context.function = parser.get_completion_function();
 	context.block = parser.get_completion_block();
@@ -3361,28 +3361,28 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 	bool is_function = false;
 
 	switch (parser.get_completion_type()) {
-		case GDScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
+		case CScriptParser::COMPLETION_BUILT_IN_TYPE_CONSTANT: {
 			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_CONSTANT;
 			r_result.class_name = Variant::get_type_name(parser.get_completion_built_in_constant());
 			r_result.class_member = p_symbol;
 			return OK;
 		} break;
-		case GDScriptParser::COMPLETION_PARENT_FUNCTION:
-		case GDScriptParser::COMPLETION_FUNCTION: {
+		case CScriptParser::COMPLETION_PARENT_FUNCTION:
+		case CScriptParser::COMPLETION_FUNCTION: {
 			is_function = true;
 			FALLTHROUGH;
 		}
-		case GDScriptParser::COMPLETION_IDENTIFIER: {
+		case CScriptParser::COMPLETION_IDENTIFIER: {
 			if (!is_function) {
 				is_function = parser.get_completion_identifier_is_function();
 			}
 
-			GDScriptParser::DataType base_type;
+			CScriptParser::DataType base_type;
 			if (context._class) {
-				if (parser.get_completion_type() != GDScriptParser::COMPLETION_PARENT_FUNCTION) {
+				if (parser.get_completion_type() != CScriptParser::COMPLETION_PARENT_FUNCTION) {
 					base_type.has_type = true;
-					base_type.kind = GDScriptParser::DataType::CLASS;
-					base_type.class_type = const_cast<GDScriptParser::ClassNode *>(context._class);
+					base_type.kind = CScriptParser::DataType::CLASS;
+					base_type.class_type = const_cast<CScriptParser::ClassNode *>(context._class);
 				} else {
 					base_type = context._class->base_type;
 				}
@@ -3392,7 +3392,7 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 
 			if (!is_function && context.block) {
 				// Lookup local variables
-				const GDScriptParser::BlockNode *block = context.block;
+				const CScriptParser::BlockNode *block = context.block;
 				while (block) {
 					if (block->variables.has(p_symbol)) {
 						r_result.type = ScriptLanguage::LookupResult::RESULT_SCRIPT_LOCATION;
@@ -3451,15 +3451,15 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 				}
 
 				// Global
-				Map<StringName, int> classes = GDScriptLanguage::get_singleton()->get_global_map();
+				Map<StringName, int> classes = CScriptLanguage::get_singleton()->get_global_map();
 				if (classes.has(p_symbol)) {
-					Variant value = GDScriptLanguage::get_singleton()->get_global_array()[classes[p_symbol]];
+					Variant value = CScriptLanguage::get_singleton()->get_global_array()[classes[p_symbol]];
 					if (value.get_type() == Variant::OBJECT) {
 						Object *obj = value;
 						if (obj) {
-							if (Object::cast_to<GDScriptNativeClass>(obj)) {
+							if (Object::cast_to<CScriptNativeClass>(obj)) {
 								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
-								r_result.class_name = Object::cast_to<GDScriptNativeClass>(obj)->get_name();
+								r_result.class_name = Object::cast_to<CScriptNativeClass>(obj)->get_name();
 							} else {
 								r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS;
 								r_result.class_name = obj->get_class();
@@ -3497,17 +3497,17 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 				}
 			}
 		} break;
-		case GDScriptParser::COMPLETION_METHOD: {
+		case CScriptParser::COMPLETION_METHOD: {
 			is_function = true;
 			FALLTHROUGH;
 		}
-		case GDScriptParser::COMPLETION_INDEX: {
-			const GDScriptParser::Node *node = parser.get_completion_node();
-			if (node->type != GDScriptParser::Node::TYPE_OPERATOR) {
+		case CScriptParser::COMPLETION_INDEX: {
+			const CScriptParser::Node *node = parser.get_completion_node();
+			if (node->type != CScriptParser::Node::TYPE_OPERATOR) {
 				break;
 			}
-			GDScriptCompletionIdentifier base;
-			if (!_guess_expression_type(context, static_cast<const GDScriptParser::OperatorNode *>(node)->arguments[0], base)) {
+			CScriptCompletionIdentifier base;
+			if (!_guess_expression_type(context, static_cast<const CScriptParser::OperatorNode *>(node)->arguments[0], base)) {
 				break;
 			}
 
@@ -3515,18 +3515,18 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 				return OK;
 			}
 		} break;
-		case GDScriptParser::COMPLETION_VIRTUAL_FUNC: {
-			GDScriptParser::DataType base_type = context._class->base_type;
+		case CScriptParser::COMPLETION_VIRTUAL_FUNC: {
+			CScriptParser::DataType base_type = context._class->base_type;
 
 			if (_lookup_symbol_from_base(base_type, p_symbol, true, r_result) == OK) {
 				return OK;
 			}
 		} break;
-		case GDScriptParser::COMPLETION_TYPE_HINT: {
-			GDScriptParser::DataType base_type = context._class->base_type;
+		case CScriptParser::COMPLETION_TYPE_HINT: {
+			CScriptParser::DataType base_type = context._class->base_type;
 			base_type.has_type = true;
-			base_type.kind = GDScriptParser::DataType::CLASS;
-			base_type.class_type = const_cast<GDScriptParser::ClassNode *>(context._class);
+			base_type.kind = CScriptParser::DataType::CLASS;
+			base_type.class_type = const_cast<CScriptParser::ClassNode *>(context._class);
 
 			if (_lookup_symbol_from_base(base_type, p_symbol, false, r_result) == OK) {
 				return OK;
@@ -3536,11 +3536,11 @@ Error GDScriptLanguage::lookup_code(const String &p_code, const String &p_symbol
 		}
 	}
 
-	for (int i = 0; i < GDScriptFunctions::FUNC_MAX; i++) {
+	for (int i = 0; i < CScriptFunctions::FUNC_MAX; i++) {
 		// this has to get run after parsing because otherwise functions like Array.max() will trigger it
-		if (GDScriptFunctions::get_func_name(GDScriptFunctions::Function(i)) == p_symbol) {
+		if (CScriptFunctions::get_func_name(CScriptFunctions::Function(i)) == p_symbol) {
 			r_result.type = ScriptLanguage::LookupResult::RESULT_CLASS_METHOD;
-			r_result.class_name = "@GDScript";
+			r_result.class_name = "@CScript";
 			r_result.class_member = p_symbol;
 			return OK;
 		}
diff --git a/modules/cscript/cscript_function.cpp b/modules/cscript/cscript_function.cpp
index 767b73595..5559563ce 100644
--- a/modules/cscript/cscript_function.cpp
+++ b/modules/cscript/cscript_function.cpp
@@ -34,7 +34,7 @@
 #include "cscript.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;
 
 	//sequential table (jump table generated by compiler)
@@ -63,14 +63,14 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 		} break;
 		case ADDR_TYPE_CLASS_CONSTANT: {
 			//todo change to index!
-			GDScript *s = p_script;
+			CScript *s = p_script;
 #ifdef DEBUG_ENABLED
 			ERR_FAIL_INDEX_V(address, _global_names_count, nullptr);
 #endif
 			const StringName *sn = &_global_names_ptr[address];
 
 			while (s) {
-				GDScript *o = s;
+				CScript *o = s;
 				while (o) {
 					Map<StringName, Variant>::Element *E = o->constants.find(*sn);
 					if (E) {
@@ -81,7 +81,7 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 				s = s->_base;
 			}
 
-			ERR_FAIL_V_MSG(nullptr, "GDScriptCompiler bug.");
+			ERR_FAIL_V_MSG(nullptr, "CScriptCompiler bug.");
 		} break;
 		case ADDR_TYPE_LOCAL_CONSTANT: {
 #ifdef DEBUG_ENABLED
@@ -98,9 +98,9 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 		} break;
 		case ADDR_TYPE_GLOBAL: {
 #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
-			return &GDScriptLanguage::get_singleton()->get_global_array()[address];
+			return &CScriptLanguage::get_singleton()->get_global_array()[address];
 		} break;
 #ifdef TOOLS_ENABLED
 		case ADDR_TYPE_NAMED_GLOBAL: {
@@ -109,8 +109,8 @@ Variant *GDScriptFunction::_get_variant(int p_address, GDScriptInstance *p_insta
 #endif
 			StringName id = _named_globals_ptr[address];
 
-			if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(id)) {
-				return (Variant *)&GDScriptLanguage::get_singleton()->get_named_globals_map()[id];
+			if (CScriptLanguage::get_singleton()->get_named_globals_map().has(id)) {
+				return (Variant *)&CScriptLanguage::get_singleton()->get_named_globals_map()[id];
 			} else {
 				r_error = "Autoload singleton '" + String(id) + "' has been removed.";
 				return nullptr;
@@ -154,7 +154,7 @@ static String _get_var_type(const Variant *p_var) {
 }
 #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;
 
 	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
 #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;
 
 	if (!_code_ptr) {
@@ -269,12 +269,12 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 #ifdef DEBUG_ENABLED
 
-	//GDScriptLanguage::get_singleton()->calls++;
+	//CScriptLanguage::get_singleton()->calls++;
 
 #endif
 
 	uint32_t alloca_size = 0;
-	GDScript *script;
+	CScript *script;
 	int ip = 0;
 	int line = _initial_line;
 
@@ -327,11 +327,11 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 						} else {
 							r_err.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
 							r_err.argument = i;
-							r_err.expected = argument_types[i].kind == GDScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT;
+							r_err.expected = argument_types[i].kind == CScriptDataType::BUILTIN ? argument_types[i].builtin_type : Variant::OBJECT;
 							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);
 						memnew_placement(&stack[i], Variant(arg));
 					} else {
@@ -374,7 +374,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 #ifdef DEBUG_ENABLED
 
 	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)                                                                                           \
@@ -408,7 +408,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 	uint64_t function_start_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_call_time = 0;
 		profile.call_count++;
@@ -484,14 +484,14 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					Object *obj_A = *a;
 					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 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.
 
-						if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == GDScriptLanguage::get_singleton()) {
-							GDScript *cmp = static_cast<GDScript *>(obj_A->get_script_instance()->get_script().ptr());
+						if (obj_A->get_script_instance() && obj_A->get_script_instance()->get_language() == CScriptLanguage::get_singleton()) {
+							CScript *cmp = static_cast<CScript *>(obj_A->get_script_instance()->get_script().ptr());
 							//bool found=false;
 							while (cmp) {
 								if (cmp == scr_B) {
@@ -505,7 +505,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 						}
 
 					} else {
-						GDScriptNativeClass *nc = Object::cast_to<GDScriptNativeClass>(obj_B);
+						CScriptNativeClass *nc = Object::cast_to<CScriptNativeClass>(obj_B);
 
 #ifdef DEBUG_ENABLED
 						if (!nc) {
@@ -769,7 +769,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 #ifdef DEBUG_ENABLED
 				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);
 				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()) +
@@ -871,7 +871,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				GET_VARIANT_PTR(src, 2);
 				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);
 
 #ifdef DEBUG_ENABLED
@@ -1038,7 +1038,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 #ifdef DEBUG_ENABLED
 				uint64_t call_time = 0;
 
-				if (GDScriptLanguage::get_singleton()->profiling) {
+				if (CScriptLanguage::get_singleton()->profiling) {
 					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);
 				}
 #ifdef DEBUG_ENABLED
-				if (GDScriptLanguage::get_singleton()->profiling) {
+				if (CScriptLanguage::get_singleton()->profiling) {
 					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) {
 				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];
 				GD_ERR_BREAK(argc < 0);
 
@@ -1114,11 +1114,11 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 				Variant::CallError err;
 
-				GDScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
+				CScriptFunctions::call(func, (const Variant **)argptrs, argc, *dst, err);
 
 #ifdef DEBUG_ENABLED
 				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) {
 						//call provided error string
 						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);
 
-				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()) {
 					gds = gds->base.ptr();
 					E = gds->member_functions.find(*methodname);
@@ -1177,7 +1177,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				if (E) {
 					*dst = E->get()->call(p_instance, (const Variant **)argptrs, argc, err);
 				} 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);
 						if (!mb) {
 							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;
 					}
 				} else {
-					if (*methodname != GDScriptLanguage::get_singleton()->strings._init) {
+					if (*methodname != CScriptLanguage::get_singleton()->strings._init) {
 						err.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
 					} else {
 						err.error = Variant::CallError::CALL_OK;
@@ -1216,7 +1216,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					CHECK_SPACE(2);
 				}
 
-				Ref<GDScriptFunctionState> gdfs = memnew(GDScriptFunctionState);
+				Ref<CScriptFunctionState> gdfs = memnew(CScriptFunctionState);
 				gdfs->function = this;
 
 				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.line = line;
 				gdfs->state.script = _script;
-				GDScriptLanguage::singleton->lock.lock();
+				CScriptLanguage::singleton->lock.lock();
 
 				_script->pending_func_states.add(&gdfs->scripts_list);
 				if (p_instance) {
@@ -1239,7 +1239,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 				} else {
 					gdfs->state.instance = nullptr;
 				}
-				GDScriptLanguage::singleton->lock.unlock();
+				CScriptLanguage::singleton->lock.unlock();
 #ifdef DEBUG_ENABLED
 				gdfs->state.function_name = name;
 				gdfs->state.script_path = _script->get_path();
@@ -1466,7 +1466,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 			OPCODE(OPCODE_BREAKPOINT) {
 #ifdef DEBUG_ENABLED
 				if (ScriptDebugger::get_singleton()) {
-					GDScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
+					CScriptLanguage::get_singleton()->debug_break("Breakpoint Statement", true);
 				}
 #endif
 				ip += 1;
@@ -1497,7 +1497,7 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 					}
 
 					if (do_break) {
-						GDScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
+						CScriptLanguage::get_singleton()->debug_break("Breakpoint", true);
 					}
 
 					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).";
 		}
 
-		if (!GDScriptLanguage::get_singleton()->debug_break(err_text, false)) {
+		if (!CScriptLanguage::get_singleton()->debug_break(err_text, false)) {
 			// 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);
@@ -1557,13 +1557,13 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 
 	OPCODES_OUT
 #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;
 		profile.total_time += time_taken;
 		profile.self_time += time_taken - function_call_time;
 		profile.frame_total_time += time_taken;
 		profile.frame_self_time += time_taken - function_call_time;
-		GDScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
+		CScriptLanguage::get_singleton()->script_frame_time += time_taken - function_call_time;
 	}
 
 	// 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)
 	if (!p_state || yielded) {
 		if (ScriptDebugger::get_singleton()) {
-			GDScriptLanguage::get_singleton()->exit_function();
+			CScriptLanguage::get_singleton()->exit_function();
 		}
 #endif
 
@@ -1590,45 +1590,45 @@ Variant GDScriptFunction::call(GDScriptInstance *p_instance, const Variant **p_a
 	return retvalue;
 }
 
-const int *GDScriptFunction::get_code() const {
+const int *CScriptFunction::get_code() const {
 	return _code_ptr;
 }
-int GDScriptFunction::get_code_size() const {
+int CScriptFunction::get_code_size() const {
 	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>");
 	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>");
 	return global_names[p_idx];
 }
 
-int GDScriptFunction::get_default_argument_count() const {
+int CScriptFunction::get_default_argument_count() const {
 	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);
 	return default_arguments[p_idx];
 }
 
-GDScriptDataType GDScriptFunction::get_return_type() const {
+CScriptDataType CScriptFunction::get_return_type() const {
 	return return_type;
 }
 
-GDScriptDataType GDScriptFunction::get_argument_type(int p_idx) const {
-	ERR_FAIL_INDEX_V(p_idx, argument_types.size(), GDScriptDataType());
+CScriptDataType CScriptFunction::get_argument_type(int p_idx) const {
+	ERR_FAIL_INDEX_V(p_idx, argument_types.size(), CScriptDataType());
 	return argument_types[p_idx];
 }
 
-StringName GDScriptFunction::get_name() const {
+StringName CScriptFunction::get_name() const {
 	return name;
 }
 
-int GDScriptFunction::get_max_stack_size() const {
+int CScriptFunction::get_max_stack_size() const {
 	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;
 	Map<StringName, _GDFKC> sdmap;
 	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) {
 	_stack_size = 0;
 	_call_size = 0;
@@ -1704,9 +1704,9 @@ GDScriptFunction::GDScriptFunction() :
 #ifdef DEBUG_ENABLED
 	_func_cname = nullptr;
 
-	GDScriptLanguage::get_singleton()->lock.lock();
-	GDScriptLanguage::get_singleton()->function_list.add(&function_list);
-	GDScriptLanguage::get_singleton()->lock.unlock();
+	CScriptLanguage::get_singleton()->lock.lock();
+	CScriptLanguage::get_singleton()->function_list.add(&function_list);
+	CScriptLanguage::get_singleton()->lock.unlock();
 
 	profile.call_count = 0;
 	profile.self_time = 0;
@@ -1721,17 +1721,17 @@ GDScriptFunction::GDScriptFunction() :
 #endif
 }
 
-GDScriptFunction::~GDScriptFunction() {
+CScriptFunction::~CScriptFunction() {
 #ifdef DEBUG_ENABLED
-	GDScriptLanguage::get_singleton()->lock.lock();
-	GDScriptLanguage::get_singleton()->function_list.remove(&function_list);
-	GDScriptLanguage::get_singleton()->lock.unlock();
+	CScriptLanguage::get_singleton()->lock.lock();
+	CScriptLanguage::get_singleton()->function_list.remove(&function_list);
+	CScriptLanguage::get_singleton()->lock.unlock();
 #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;
 	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;
 	}
 
-	Ref<GDScriptFunctionState> self = *p_args[p_argcount - 1];
+	Ref<CScriptFunctionState> self = *p_args[p_argcount - 1];
 
 	if (self.is_null()) {
 		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);
 }
 
-bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
+bool CScriptFunctionState::is_valid(bool p_extended_check) const {
 	if (function == nullptr) {
 		return false;
 	}
 
 	if (p_extended_check) {
 #ifndef NO_THREADS
-		MutexLock lock(GDScriptLanguage::get_singleton()->lock);
+		MutexLock lock(CScriptLanguage::get_singleton()->lock);
 #endif
 		// Script gone?
 		if (!scripts_list.in_list()) {
@@ -1785,11 +1785,11 @@ bool GDScriptFunctionState::is_valid(bool p_extended_check) const {
 	return true;
 }
 
-Variant GDScriptFunctionState::resume(const Variant &p_arg) {
+Variant CScriptFunctionState::resume(const Variant &p_arg) {
 	ERR_FAIL_COND_V(!function, Variant());
 	{
 #ifndef NO_THREADS
-		MutexLock lock(GDScriptLanguage::singleton->lock);
+		MutexLock lock(CScriptLanguage::singleton->lock);
 #endif
 		if (!scripts_list.in_list()) {
 #ifdef DEBUG_ENABLED
@@ -1816,13 +1816,13 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 
 	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.
 	if (ret.is_ref()) {
-		GDScriptFunctionState *gdfs = Object::cast_to<GDScriptFunctionState>(ret);
+		CScriptFunctionState *gdfs = Object::cast_to<CScriptFunctionState>(ret);
 		if (gdfs && gdfs->function == function) {
 			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
 		if (ScriptDebugger::get_singleton()) {
-			GDScriptLanguage::get_singleton()->exit_function();
+			CScriptLanguage::get_singleton()->exit_function();
 		}
 #endif
 	}
@@ -1846,7 +1846,7 @@ Variant GDScriptFunctionState::resume(const Variant &p_arg) {
 	return ret;
 }
 
-void GDScriptFunctionState::_clear_stack() {
+void CScriptFunctionState::_clear_stack() {
 	if (state.stack_size) {
 		Variant *stack = (Variant *)state.stack.ptr();
 		for (int i = 0; i < state.stack_size; i++) {
@@ -1856,24 +1856,24 @@ void GDScriptFunctionState::_clear_stack() {
 	}
 }
 
-void GDScriptFunctionState::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("resume", "arg"), &GDScriptFunctionState::resume, DEFVAL(Variant()));
-	ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &GDScriptFunctionState::is_valid, DEFVAL(false));
-	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, "_signal_callback", &GDScriptFunctionState::_signal_callback, MethodInfo("_signal_callback"));
+void CScriptFunctionState::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("resume", "arg"), &CScriptFunctionState::resume, DEFVAL(Variant()));
+	ClassDB::bind_method(D_METHOD("is_valid", "extended_check"), &CScriptFunctionState::is_valid, DEFVAL(false));
+	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)));
 }
 
-GDScriptFunctionState::GDScriptFunctionState() :
+CScriptFunctionState::CScriptFunctionState() :
 		scripts_list(this),
 		instances_list(this) {
 	function = nullptr;
 }
 
-GDScriptFunctionState::~GDScriptFunctionState() {
+CScriptFunctionState::~CScriptFunctionState() {
 	_clear_stack();
-	GDScriptLanguage::singleton->lock.lock();
+	CScriptLanguage::singleton->lock.lock();
 	scripts_list.remove_from_list();
 	instances_list.remove_from_list();
-	GDScriptLanguage::singleton->lock.unlock();
+	CScriptLanguage::singleton->lock.unlock();
 }
diff --git a/modules/cscript/cscript_function.h b/modules/cscript/cscript_function.h
index 5954560a9..1c7cdb420 100644
--- a/modules/cscript/cscript_function.h
+++ b/modules/cscript/cscript_function.h
@@ -38,17 +38,17 @@
 #include "core/string_name.h"
 #include "core/variant.h"
 
-class GDScriptInstance;
-class GDScript;
+class CScriptInstance;
+class CScript;
 
-struct GDScriptDataType {
+struct CScriptDataType {
 	bool has_type;
 	enum {
 		UNINITIALIZED,
 		BUILTIN,
 		NATIVE,
 		SCRIPT,
-		GDSCRIPT,
+		CSCRIPT,
 	} kind;
 	Variant::Type builtin_type;
 	StringName native_type;
@@ -94,7 +94,7 @@ struct GDScriptDataType {
 				return true;
 			} break;
 			case SCRIPT:
-			case GDSCRIPT: {
+			case CSCRIPT: {
 				if (p_variant.get_type() == Variant::NIL) {
 					return true;
 				}
@@ -136,7 +136,7 @@ struct GDScriptDataType {
 					info.class_name = native_type;
 				} break;
 				case SCRIPT:
-				case GDSCRIPT: {
+				case CSCRIPT: {
 					info.type = Variant::OBJECT;
 					info.class_name = script_type->get_instance_base_type();
 				} break;
@@ -148,14 +148,14 @@ struct GDScriptDataType {
 		return info;
 	}
 
-	GDScriptDataType() :
+	CScriptDataType() :
 			has_type(false),
 			kind(UNINITIALIZED),
 			builtin_type(Variant::NIL),
 			script_type(nullptr) {}
 };
 
-class GDScriptFunction {
+class CScriptFunction {
 public:
 	enum Opcode {
 		OPCODE_OPERATOR,
@@ -224,7 +224,7 @@ public:
 	};
 
 private:
-	friend class GDScriptCompiler;
+	friend class CScriptCompiler;
 
 	StringName source;
 
@@ -248,7 +248,7 @@ private:
 	bool _static;
 	MultiplayerAPI::RPCMode rpc_mode;
 
-	GDScript *_script;
+	CScript *_script;
 
 	StringName name;
 	Vector<Variant> constants;
@@ -258,8 +258,8 @@ private:
 #endif
 	Vector<int> default_arguments;
 	Vector<int> code;
-	Vector<GDScriptDataType> argument_types;
-	GDScriptDataType return_type;
+	Vector<CScriptDataType> argument_types;
+	CScriptDataType return_type;
 
 #ifdef TOOLS_ENABLED
 	Vector<StringName> arg_names;
@@ -267,12 +267,12 @@ private:
 
 	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;
 
-	friend class GDScriptLanguage;
+	friend class CScriptLanguage;
 
-	SelfList<GDScriptFunction> function_list;
+	SelfList<CScriptFunction> function_list;
 #ifdef DEBUG_ENABLED
 	CharString func_cname;
 	const char *_func_cname;
@@ -294,8 +294,8 @@ private:
 
 public:
 	struct CallState {
-		GDScript *script;
-		GDScriptInstance *instance;
+		CScript *script;
+		CScriptInstance *instance;
 #ifdef DEBUG_ENABLED
 		StringName function_name;
 		String script_path;
@@ -322,9 +322,9 @@ public:
 	int get_max_stack_size() const;
 	int get_default_argument_count() const;
 	int get_default_argument_addr(int p_idx) const;
-	GDScriptDataType get_return_type() const;
-	GDScriptDataType get_argument_type(int p_idx) const;
-	GDScript *get_script() const {
+	CScriptDataType get_return_type() const;
+	CScriptDataType get_argument_type(int p_idx) const;
+	CScript *get_script() const {
 		return _script;
 	}
 	StringName get_source() const {
@@ -353,25 +353,25 @@ public:
 		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 {
 		return rpc_mode;
 	}
-	GDScriptFunction();
-	~GDScriptFunction();
+	CScriptFunction();
+	~CScriptFunction();
 };
 
-class GDScriptFunctionState : public Reference {
-	GDCLASS(GDScriptFunctionState, Reference);
-	friend class GDScriptFunction;
-	GDScriptFunction *function;
-	GDScriptFunction::CallState state;
+class CScriptFunctionState : public Reference {
+	GDCLASS(CScriptFunctionState, Reference);
+	friend class CScriptFunction;
+	CScriptFunction *function;
+	CScriptFunction::CallState state;
 	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<GDScriptFunctionState> instances_list;
+	SelfList<CScriptFunctionState> scripts_list;
+	SelfList<CScriptFunctionState> instances_list;
 
 protected:
 	static void _bind_methods();
@@ -382,8 +382,8 @@ public:
 
 	void _clear_stack();
 
-	GDScriptFunctionState();
-	~GDScriptFunctionState();
+	CScriptFunctionState();
+	~CScriptFunctionState();
 };
 
-#endif // GDSCRIPT_FUNCTION_H
+#endif // CSCRIPT_FUNCTION_H
diff --git a/modules/cscript/cscript_functions.cpp b/modules/cscript/cscript_functions.cpp
index f2eff8e4d..7c33ae612 100644
--- a/modules/cscript/cscript_functions.cpp
+++ b/modules/cscript/cscript_functions.cpp
@@ -40,7 +40,7 @@
 #include "core/variant_parser.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, "");
 
 	static const char *_names[FUNC_MAX] = {
@@ -140,7 +140,7 @@ const char *GDScriptFunctions::get_func_name(Function 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;
 #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_NUM(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;
 		case MATH_STEP_DECIMALS: {
 			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();
 			}
 
-			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			ScriptLanguage *script = CScriptLanguage::get_singleton();
 			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) + "()";
 			}
@@ -1041,15 +1041,15 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 				if (!obj) {
 					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.argument = 0;
 					r_error.expected = Variant::DICTIONARY;
 					r_ret = RTR("Not a script with an instance");
 					return;
 				} else {
-					GDScriptInstance *ins = static_cast<GDScriptInstance *>(obj->get_script_instance());
-					Ref<GDScript> base = ins->get_script();
+					CScriptInstance *ins = static_cast<CScriptInstance *>(obj->get_script_instance());
+					Ref<CScript> base = ins->get_script();
 					if (base.is_null()) {
 						r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
 						r_error.argument = 0;
@@ -1058,7 +1058,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 						return;
 					}
 
-					GDScript *p = base.ptr();
+					CScript *p = base.ptr();
 					Vector<StringName> sname;
 
 					while (p->_owner) {
@@ -1084,7 +1084,7 @@ void GDScriptFunctions::call(Function p_func, const Variant **p_args, int p_arg_
 					d["@subpath"] = cp;
 					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())) {
 							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;
 			}
 
-			Ref<GDScript> gdscr = scr;
+			Ref<CScript> gdscr = scr;
 
 			if (!gdscr.is_valid()) {
 				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;
 			}
 
-			GDScriptInstance *ins = static_cast<GDScriptInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
-			Ref<GDScript> gd_ref = ins->get_script();
+			CScriptInstance *ins = static_cast<CScriptInstance *>(static_cast<Object *>(r_ret)->get_script_instance());
+			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())) {
 					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: {
 			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++) {
 				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: {
 			VALIDATE_ARG_COUNT(0);
 
-			ScriptLanguage *script = GDScriptLanguage::get_singleton();
+			ScriptLanguage *script = CScriptLanguage::get_singleton();
 			Array ret;
 			for (int i = 0; i < script->debug_get_stack_level_count(); i++) {
 				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,
 	//way too controversial..
 
@@ -1473,7 +1473,7 @@ bool GDScriptFunctions::is_deterministic(Function p_func) {
 	return false;
 }
 
-MethodInfo GDScriptFunctions::get_info(Function p_func) {
+MethodInfo CScriptFunctions::get_info(Function p_func) {
 #ifdef DEBUG_ENABLED
 	//using a switch, so the compiler generates a jumptable
 
diff --git a/modules/cscript/cscript_functions.h b/modules/cscript/cscript_functions.h
index a7dbf11cf..57458ba6a 100644
--- a/modules/cscript/cscript_functions.h
+++ b/modules/cscript/cscript_functions.h
@@ -32,7 +32,7 @@
 
 #include "core/variant.h"
 
-class GDScriptFunctions {
+class CScriptFunctions {
 public:
 	enum Function {
 		MATH_SIN,
@@ -135,4 +135,4 @@ public:
 	static MethodInfo get_info(Function p_func);
 };
 
-#endif // GDSCRIPT_FUNCTIONS_H
+#endif // CSCRIPT_FUNCTIONS_H
diff --git a/modules/cscript/cscript_parser.cpp b/modules/cscript/cscript_parser.cpp
index f7651d716..602d500ba 100644
--- a/modules/cscript/cscript_parser.cpp
+++ b/modules/cscript/cscript_parser.cpp
@@ -41,7 +41,7 @@
 #include "cscript.h"
 
 template <class T>
-T *GDScriptParser::alloc_node() {
+T *CScriptParser::alloc_node() {
 	T *t = memnew(T);
 
 	t->next = list;
@@ -57,23 +57,23 @@ T *GDScriptParser::alloc_node() {
 }
 
 #ifdef DEBUG_ENABLED
-static String _find_function_name(const GDScriptParser::OperatorNode *p_call);
+static String _find_function_name(const CScriptParser::OperatorNode *p_call);
 #endif // DEBUG_ENABLED
 
-bool GDScriptParser::_end_statement() {
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
+bool CScriptParser::_end_statement() {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_SEMICOLON) {
 		tokenizer->advance();
 		return true; //handle next
-	} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+	} else if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 		return true; //will be handled properly
 	}
 
 	return false;
 }
 
-void GDScriptParser::_set_end_statement_error(String p_name) {
+void CScriptParser::_set_end_statement_error(String p_name) {
 	String error_msg;
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER) {
 		error_msg = vformat("Expected end of statement (\"%s\"), got %s (\"%s\") instead.", p_name, tokenizer->get_token_name(tokenizer->get_token()), tokenizer->get_token_identifier());
 	} else {
 		error_msg = vformat("Expected end of statement (\"%s\"), got %s instead.", p_name, tokenizer->get_token_name(tokenizer->get_token()));
@@ -81,8 +81,8 @@ void GDScriptParser::_set_end_statement_error(String p_name) {
 	_set_error(error_msg);
 }
 
-bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
-	if (tokenizer->get_token() != GDScriptTokenizer::TK_COLON) {
+bool CScriptParser::_enter_indent_block(BlockNode *p_block) {
+	if (tokenizer->get_token() != CScriptTokenizer::TK_COLON) {
 		// report location at the previous token (on the previous line)
 		int error_line = tokenizer->get_token_line(-1);
 		int error_column = tokenizer->get_token_column(-1);
@@ -91,11 +91,11 @@ bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
 	}
 	tokenizer->advance();
 
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 		return false;
 	}
 
-	if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
+	if (tokenizer->get_token() != CScriptTokenizer::TK_NEWLINE) {
 		// be more python-like
 		IndentLevel current_level = indent_level.back()->get();
 		indent_level.push_back(current_level);
@@ -105,11 +105,11 @@ bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
 	}
 
 	while (true) {
-		if (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE) {
+		if (tokenizer->get_token() != CScriptTokenizer::TK_NEWLINE) {
 			return false; //wtf
-		} else if (tokenizer->get_token(1) == GDScriptTokenizer::TK_EOF) {
+		} else if (tokenizer->get_token(1) == CScriptTokenizer::TK_EOF) {
 			return false;
-		} else if (tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
+		} else if (tokenizer->get_token(1) != CScriptTokenizer::TK_NEWLINE) {
 			int indent = tokenizer->get_token_line_indent();
 			int tabs = tokenizer->get_token_line_tab_indent();
 			IndentLevel current_level = indent_level.back()->get();
@@ -137,18 +137,18 @@ bool GDScriptParser::_enter_indent_block(BlockNode *p_block) {
 	}
 }
 
-bool GDScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete, bool p_parsing_constant) {
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+bool CScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bool p_static, bool p_can_codecomplete, bool p_parsing_constant) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 		tokenizer->advance();
 	} else {
 		parenthesis++;
 		int argidx = 0;
 
 		while (true) {
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 				_make_completable_call(argidx);
 				completion_node = p_parent;
-			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
+			} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING && tokenizer->get_token(1) == CScriptTokenizer::TK_CURSOR) {
 				//completing a string argument..
 				completion_cursor = tokenizer->get_token_constant();
 
@@ -165,12 +165,12 @@ bool GDScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bo
 
 			p_args.push_back(arg);
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 				tokenizer->advance();
 				break;
 
-			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
-				if (tokenizer->get_token(1) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+			} else if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token(1) == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 					_set_error("Expression expected");
 					return false;
 				}
@@ -189,7 +189,7 @@ bool GDScriptParser::_parse_arguments(Node *p_parent, Vector<Node *> &p_args, bo
 	return true;
 }
 
-void GDScriptParser::_make_completable_call(int p_arg) {
+void CScriptParser::_make_completable_call(int p_arg) {
 	completion_cursor = StringName();
 	completion_type = COMPLETION_CALL_ARGUMENTS;
 	completion_class = current_class;
@@ -201,13 +201,13 @@ void GDScriptParser::_make_completable_call(int p_arg) {
 	tokenizer->advance();
 }
 
-bool GDScriptParser::_get_completable_identifier(CompletionType p_type, StringName &identifier) {
+bool CScriptParser::_get_completable_identifier(CompletionType p_type, StringName &identifier) {
 	identifier = StringName();
 	if (tokenizer->is_token_literal()) {
 		identifier = tokenizer->get_token_literal();
 		tokenizer->advance();
 	}
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 		completion_cursor = identifier;
 		completion_type = p_type;
 		completion_class = current_class;
@@ -223,7 +223,7 @@ bool GDScriptParser::_get_completable_identifier(CompletionType p_type, StringNa
 			tokenizer->advance();
 		}
 
-		if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+		if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 			completion_ident_is_call = true;
 		}
 		return true;
@@ -232,7 +232,7 @@ bool GDScriptParser::_get_completable_identifier(CompletionType p_type, StringNa
 	return false;
 }
 
-GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign, bool p_parsing_constant) {
+CScriptParser::Node *CScriptParser::_parse_expression(Node *p_parent, bool p_static, bool p_allow_assign, bool p_parsing_constant) {
 	//Vector<Node*> expressions;
 	//Vector<OperatorNode::Operator> operators;
 
@@ -249,22 +249,22 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 		if (parenthesis > 0) {
 			//remove empty space (only allowed if inside parenthesis
-			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 		}
 
 		// Check that the next token is not TK_CURSOR and if it is, the offset should be incremented.
 		int next_valid_offset = 1;
-		if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_CURSOR) {
+		if (tokenizer->get_token(next_valid_offset) == CScriptTokenizer::TK_CURSOR) {
 			next_valid_offset++;
 			// There is a chunk of the identifier that also needs to be ignored (not always there!)
-			if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_IDENTIFIER) {
+			if (tokenizer->get_token(next_valid_offset) == CScriptTokenizer::TK_IDENTIFIER) {
 				next_valid_offset++;
 			}
 		}
 
-		if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+		if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 			//subexpression ()
 			tokenizer->advance();
 			parenthesis++;
@@ -274,14 +274,14 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				return nullptr;
 			}
 
-			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 				_set_error("Expected ')' in expression");
 				return nullptr;
 			}
 
 			tokenizer->advance();
 			expr = subexpr;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_DOLLAR) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_DOLLAR) {
 			tokenizer->advance();
 
 			String path;
@@ -292,7 +292,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 			while (!done) {
 				switch (tokenizer->get_token()) {
-					case GDScriptTokenizer::TK_CURSOR: {
+					case CScriptTokenizer::TK_CURSOR: {
 						completion_type = COMPLETION_GET_NODE;
 						completion_class = current_class;
 						completion_function = current_function;
@@ -303,7 +303,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						completion_found = true;
 						tokenizer->advance();
 					} break;
-					case GDScriptTokenizer::TK_CONSTANT: {
+					case CScriptTokenizer::TK_CONSTANT: {
 						if (!need_identifier) {
 							done = true;
 							break;
@@ -319,7 +319,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						need_identifier = false;
 
 					} break;
-					case GDScriptTokenizer::TK_OP_DIV: {
+					case CScriptTokenizer::TK_OP_DIV: {
 						if (need_identifier) {
 							done = true;
 							break;
@@ -369,55 +369,55 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 			expr = op;
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 			tokenizer->advance();
 			continue; //no point in cursor in the middle of expression
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT) {
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = tokenizer->get_token_constant();
 			constant->datatype = _type_from_variant(constant->value);
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_PI) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONST_PI) {
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_PI;
 			constant->datatype = _type_from_variant(constant->value);
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_TAU) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONST_TAU) {
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_TAU;
 			constant->datatype = _type_from_variant(constant->value);
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_INF) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONST_INF) {
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_INF;
 			constant->datatype = _type_from_variant(constant->value);
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONST_NAN) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONST_NAN) {
 			//constant defined by tokenizer
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			constant->value = Math_NAN;
 			constant->datatype = _type_from_variant(constant->value);
 			tokenizer->advance();
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_PRELOAD) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_PR_PRELOAD) {
 			//constant defined by tokenizer
 			tokenizer->advance();
-			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+			if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 				_set_error("Expected '(' after 'preload'");
 				return nullptr;
 			}
 			tokenizer->advance();
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 				completion_cursor = StringName();
 				completion_node = p_parent;
 				completion_type = COMPLETION_RESOURCE_PATH;
@@ -500,12 +500,12 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 			}
 
-			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 				_set_error("Expected ')' after 'preload' path");
 				return nullptr;
 			}
 
-			Ref<GDScript> gds = res;
+			Ref<CScript> gds = res;
 			if (gds.is_valid() && !gds->is_valid()) {
 				_set_error("Couldn't fully preload the script, possible cyclic reference or compilation error. Use \"load()\" instead if a cyclic reference is intended.");
 				return nullptr;
@@ -518,7 +518,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			constant->datatype = _type_from_variant(constant->value);
 
 			expr = constant;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_YIELD) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_PR_YIELD) {
 			if (!current_function) {
 				_set_error("\"yield()\" can only be used inside function blocks.");
 				return nullptr;
@@ -527,7 +527,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			current_function->has_yield = true;
 
 			tokenizer->advance();
-			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+			if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 				_set_error("Expected \"(\" after \"yield\".");
 				return nullptr;
 			}
@@ -537,11 +537,11 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			OperatorNode *yield = alloc_node<OperatorNode>();
 			yield->op = OperatorNode::OP_YIELD;
 
-			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 				expr = yield;
 				tokenizer->advance();
 			} else {
@@ -553,14 +553,14 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 				yield->arguments.push_back(object);
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 					_set_error("Expected \",\" after the first argument of \"yield\".");
 					return nullptr;
 				}
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 					completion_cursor = StringName();
 					completion_node = object;
 					completion_type = COMPLETION_YIELD;
@@ -579,7 +579,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 				yield->arguments.push_back(signal);
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 					_set_error("Expected \")\" after the second argument of \"yield\".");
 					return nullptr;
 				}
@@ -591,7 +591,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				expr = yield;
 			}
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_SELF) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_SELF) {
 			if (p_static) {
 				_set_error("\"self\" isn't allowed in a static function or constant expression.");
 				return nullptr;
@@ -600,7 +600,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			SelfNode *self = alloc_node<SelfNode>();
 			tokenizer->advance();
 			expr = self;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token(1) == CScriptTokenizer::TK_PERIOD) {
 			Variant::Type bi_type = tokenizer->get_token_type();
 			tokenizer->advance(2);
 
@@ -615,7 +615,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				return nullptr;
 			}
 			if (!Variant::has_constant(bi_type, identifier)) {
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN &&
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_OPEN &&
 						Variant::is_method_const(bi_type, identifier) &&
 						Variant::get_method_return_type(bi_type, identifier) == bi_type) {
 					tokenizer->advance();
@@ -664,7 +664,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				expr = cn;
 			}
 
-		} else if (tokenizer->get_token(next_valid_offset) == GDScriptTokenizer::TK_PARENTHESIS_OPEN && tokenizer->is_token_literal()) {
+		} else if (tokenizer->get_token(next_valid_offset) == CScriptTokenizer::TK_PARENTHESIS_OPEN && tokenizer->is_token_literal()) {
 			// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
 			//function or constructor
 
@@ -674,11 +674,11 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			//Do a quick Array and Dictionary Check.  Replace if either require no arguments.
 			bool replaced = false;
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE) {
 				Variant::Type ct = tokenizer->get_token_type();
 				if (!p_parsing_constant) {
 					if (ct == Variant::ARRAY) {
-						if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						if (tokenizer->get_token(2) == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 							ArrayNode *arr = alloc_node<ArrayNode>();
 							expr = arr;
 							replaced = true;
@@ -686,7 +686,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						}
 					}
 					if (ct == Variant::DICTIONARY) {
-						if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						if (tokenizer->get_token(2) == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 							DictionaryNode *dict = alloc_node<DictionaryNode>();
 							expr = dict;
 							replaced = true;
@@ -701,7 +701,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					op->arguments.push_back(tn);
 					tokenizer->advance(2);
 				}
-			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_FUNC) {
+			} else if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_FUNC) {
 				BuiltInFunctionNode *bn = alloc_node<BuiltInFunctionNode>();
 				bn->function = tokenizer->get_token_built_in_func();
 				op->arguments.push_back(bn);
@@ -720,7 +720,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				tokenizer->advance(1);
 			}
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 				_make_completable_call(0);
 				completion_node = op;
 			}
@@ -754,26 +754,26 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 #ifdef DEBUG_ENABLED
 					LocalVarNode *lv = b->variables[identifier];
 					switch (tokenizer->get_token()) {
-						case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
-						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
-						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
-						case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
-						case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
-						case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
-						case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
-						case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
-						case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
-						case GDScriptTokenizer::TK_OP_ASSIGN_SUB: {
+						case CScriptTokenizer::TK_OP_ASSIGN_ADD:
+						case CScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+						case CScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+						case CScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+						case CScriptTokenizer::TK_OP_ASSIGN_DIV:
+						case CScriptTokenizer::TK_OP_ASSIGN_MOD:
+						case CScriptTokenizer::TK_OP_ASSIGN_MUL:
+						case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+						case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+						case CScriptTokenizer::TK_OP_ASSIGN_SUB: {
 							if (lv->assignments == 0) {
 								if (!lv->datatype.has_type) {
 									_set_error("Using assignment with operation on a variable that was never assigned.");
 									return nullptr;
 								}
-								_add_warning(GDScriptWarning::UNASSIGNED_VARIABLE_OP_ASSIGN, -1, identifier.operator String());
+								_add_warning(CScriptWarning::UNASSIGNED_VARIABLE_OP_ASSIGN, -1, identifier.operator String());
 							}
 							FALLTHROUGH;
 						}
-						case GDScriptTokenizer::TK_OP_ASSIGN: {
+						case CScriptTokenizer::TK_OP_ASSIGN: {
 							lv->assignments += 1;
 							lv->usages--; // Assignment is not really usage
 						} break;
@@ -791,20 +791,20 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				if (cln->constant_expressions.has(identifier)) {
 					expr = cln->constant_expressions[identifier].expression;
 					bfn = true;
-				} else if (GDScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
+				} else if (CScriptLanguage::get_singleton()->get_global_map().has(identifier)) {
 					//check from constants
 					ConstantNode *constant = alloc_node<ConstantNode>();
-					constant->value = GDScriptLanguage::get_singleton()->get_global_array()[GDScriptLanguage::get_singleton()->get_global_map()[identifier]];
+					constant->value = CScriptLanguage::get_singleton()->get_global_array()[CScriptLanguage::get_singleton()->get_global_map()[identifier]];
 					constant->datatype = _type_from_variant(constant->value);
 					constant->line = id_line;
 					expr = constant;
 					bfn = true;
 				}
 
-				if (!bfn && GDScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
+				if (!bfn && CScriptLanguage::get_singleton()->get_named_globals_map().has(identifier)) {
 					//check from singletons
 					ConstantNode *constant = alloc_node<ConstantNode>();
-					constant->value = GDScriptLanguage::get_singleton()->get_named_globals_map()[identifier];
+					constant->value = CScriptLanguage::get_singleton()->get_named_globals_map()[identifier];
 					expr = constant;
 					bfn = true;
 				}
@@ -824,7 +824,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					if (!bfn) {
 						// Using current_class instead of cln here, since cln is const*
 						_determine_inheritance(current_class, false);
-						if (cln->base_type.has_type && cln->base_type.kind == DataType::GDSCRIPT && cln->base_type.script_type->is_valid()) {
+						if (cln->base_type.has_type && cln->base_type.kind == DataType::CSCRIPT && cln->base_type.script_type->is_valid()) {
 							Map<StringName, Variant> parent_constants;
 							current_class->base_type.script_type->get_constants(&parent_constants);
 							if (parent_constants.has(identifier)) {
@@ -844,17 +844,17 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					int arg_idx = current_function->arguments.find(identifier);
 					if (arg_idx != -1) {
 						switch (tokenizer->get_token()) {
-							case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
-							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
-							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
-							case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
-							case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
-							case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
-							case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
-							case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
-							case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
-							case GDScriptTokenizer::TK_OP_ASSIGN_SUB:
-							case GDScriptTokenizer::TK_OP_ASSIGN: {
+							case CScriptTokenizer::TK_OP_ASSIGN_ADD:
+							case CScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+							case CScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+							case CScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+							case CScriptTokenizer::TK_OP_ASSIGN_DIV:
+							case CScriptTokenizer::TK_OP_ASSIGN_MOD:
+							case CScriptTokenizer::TK_OP_ASSIGN_MUL:
+							case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+							case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+							case CScriptTokenizer::TK_OP_ASSIGN_SUB:
+							case CScriptTokenizer::TK_OP_ASSIGN: {
 								// Assignment is not really usage
 							} break;
 							default: {
@@ -870,23 +870,23 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				expr = id;
 			}
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ADD || tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB || tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT || tokenizer->get_token() == GDScriptTokenizer::TK_OP_BIT_INVERT) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_OP_ADD || tokenizer->get_token() == CScriptTokenizer::TK_OP_SUB || tokenizer->get_token() == CScriptTokenizer::TK_OP_NOT || tokenizer->get_token() == CScriptTokenizer::TK_OP_BIT_INVERT) {
 			//single prefix operators like !expr +expr -expr ++expr --expr
 			alloc_node<OperatorNode>();
 			Expression e;
 			e.is_op = true;
 
 			switch (tokenizer->get_token()) {
-				case GDScriptTokenizer::TK_OP_ADD:
+				case CScriptTokenizer::TK_OP_ADD:
 					e.op = OperatorNode::OP_POS;
 					break;
-				case GDScriptTokenizer::TK_OP_SUB:
+				case CScriptTokenizer::TK_OP_SUB:
 					e.op = OperatorNode::OP_NEG;
 					break;
-				case GDScriptTokenizer::TK_OP_NOT:
+				case CScriptTokenizer::TK_OP_NOT:
 					e.op = OperatorNode::OP_NOT;
 					break;
-				case GDScriptTokenizer::TK_OP_BIT_INVERT:
+				case CScriptTokenizer::TK_OP_BIT_INVERT:
 					e.op = OperatorNode::OP_BIT_INVERT;
 					break;
 				default: {
@@ -895,7 +895,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 			tokenizer->advance();
 
-			if (e.op != OperatorNode::OP_NOT && tokenizer->get_token() == GDScriptTokenizer::TK_OP_NOT) {
+			if (e.op != OperatorNode::OP_NOT && tokenizer->get_token() == CScriptTokenizer::TK_OP_NOT) {
 				_set_error("Misplaced 'not'.");
 				return nullptr;
 			}
@@ -910,7 +910,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			op->arguments.push_back(subexpr);
 			expr=op;*/
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_IS && tokenizer->get_token(1) == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_PR_IS && tokenizer->get_token(1) == CScriptTokenizer::TK_BUILT_IN_TYPE) {
 			// 'is' operator with built-in type
 			if (!expr) {
 				_set_error("Expected identifier before 'is' operator");
@@ -928,7 +928,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			tokenizer->advance();
 
 			expr = op;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_OPEN) {
 			// array
 			tokenizer->advance();
 
@@ -936,16 +936,16 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			bool expecting_comma = false;
 
 			while (true) {
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 					_set_error("Unterminated array");
 					return nullptr;
 
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 					tokenizer->advance(); //ignore newline
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 					if (!expecting_comma) {
 						_set_error("expression or ']' expected");
 						return nullptr;
@@ -969,7 +969,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			}
 
 			expr = arr;
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
 			// array
 			tokenizer->advance();
 
@@ -990,11 +990,11 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			DictExpect expecting = DICT_EXPECT_KEY;
 
 			while (true) {
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 					_set_error("Unterminated dictionary");
 					return nullptr;
 
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 					if (expecting == DICT_EXPECT_COLON) {
 						_set_error("':' expected");
 						return nullptr;
@@ -1005,9 +1005,9 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					}
 					tokenizer->advance();
 					break;
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 					tokenizer->advance(); //ignore newline
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 					if (expecting == DICT_EXPECT_KEY) {
 						_set_error("key or '}' expected");
 						return nullptr;
@@ -1024,7 +1024,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					expecting = DICT_EXPECT_KEY;
 					tokenizer->advance(); //ignore newline
 
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
 					if (expecting == DICT_EXPECT_KEY) {
 						_set_error("key or '}' expected");
 						return nullptr;
@@ -1051,7 +1051,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					}
 
 					if (expecting == DICT_EXPECT_KEY) {
-						if (tokenizer->is_token_literal() && tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						if (tokenizer->is_token_literal() && tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 							// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
 							//lua style identifier, easier to write
 							ConstantNode *cn = alloc_node<ConstantNode>();
@@ -1077,8 +1077,8 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 						}
 						expecting = DICT_EXPECT_COMMA;
 
-						if (key->type == GDScriptParser::Node::TYPE_CONSTANT) {
-							Variant const &keyName = static_cast<const GDScriptParser::ConstantNode *>(key)->value;
+						if (key->type == CScriptParser::Node::TYPE_CONSTANT) {
+							Variant const &keyName = static_cast<const CScriptParser::ConstantNode *>(key)->value;
 
 							if (keys.has(keyName)) {
 								_set_error("Duplicate key found in Dictionary literal");
@@ -1098,7 +1098,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 			expr = dict;
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && (tokenizer->is_token_literal(1) || tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR)) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD && (tokenizer->is_token_literal(1) || tokenizer->get_token(1) == CScriptTokenizer::TK_CURSOR)) {
 			// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
 			// parent call
 
@@ -1116,7 +1116,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			id->name = identifier;
 			op->arguments.push_back(id);
 
-			if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+			if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 				if (!is_completion) {
 					_set_error("Expected '(' for parent function call.");
 					return nullptr;
@@ -1130,7 +1130,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 			expr = op;
 
-		} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && expression.size() > 0 && expression[expression.size() - 1].is_op && expression[expression.size() - 1].op == OperatorNode::OP_IS) {
+		} else if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE && expression.size() > 0 && expression[expression.size() - 1].is_op && expression[expression.size() - 1].op == OperatorNode::OP_IS) {
 			Expression e = expression[expression.size() - 1];
 			e.op = OperatorNode::OP_IS_BUILTIN;
 			expression.write[expression.size() - 1] = e;
@@ -1145,7 +1145,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 			return nullptr; //nothing
 		}
 
-		ERR_FAIL_COND_V_MSG(!expr, nullptr, "GDScriptParser bug, couldn't figure out what expression is.");
+		ERR_FAIL_COND_V_MSG(!expr, nullptr, "CScriptParser bug, couldn't figure out what expression is.");
 
 		/******************/
 		/* Parse Indexing */
@@ -1154,14 +1154,14 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 		while (true) {
 			//expressions can be indexed any number of times
 
-			if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+			if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD) {
 				//indexing using "."
 
-				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_CURSOR && !tokenizer->is_token_literal(1)) {
+				if (tokenizer->get_token(1) != CScriptTokenizer::TK_CURSOR && !tokenizer->is_token_literal(1)) {
 					// We check with is_token_literal, as this allows us to use match/sync/etc. as a name
 					_set_error("Expected identifier as member");
 					return nullptr;
-				} else if (tokenizer->get_token(2) == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				} else if (tokenizer->get_token(2) == CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 					//call!!
 					OperatorNode *op = alloc_node<OperatorNode>();
 					op->op = OperatorNode::OP_CALL;
@@ -1181,7 +1181,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					op->arguments.push_back(id); // call func
 					//get arguments
 					tokenizer->advance(1);
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 						_make_completable_call(0);
 						completion_node = op;
 					}
@@ -1216,7 +1216,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					expr = op;
 				}
 
-			} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_OPEN) {
+			} else if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_OPEN) {
 				//indexing using "[]"
 				OperatorNode *op = alloc_node<OperatorNode>();
 				op->op = OperatorNode::OP_INDEX;
@@ -1230,7 +1230,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					return nullptr;
 				}
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_BRACKET_CLOSE) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_BRACKET_CLOSE) {
 					_set_error("Expected ']'");
 					return nullptr;
 				}
@@ -1250,7 +1250,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 		/*****************/
 
 		bool has_casting = expr->type == Node::TYPE_CAST;
-		if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_AS) {
+		if (tokenizer->get_token() == CScriptTokenizer::TK_PR_AS) {
 			if (has_casting) {
 				_set_error("Unexpected 'as'.");
 				return nullptr;
@@ -1271,7 +1271,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 		if (parenthesis > 0) {
 			//remove empty space (only allowed if inside parenthesis
-			while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+			while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 				tokenizer->advance();
 			}
 		}
@@ -1296,59 +1296,59 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 
 		switch (tokenizer->get_token()) { //see operator
 
-			case GDScriptTokenizer::TK_OP_IN:
+			case CScriptTokenizer::TK_OP_IN:
 				op = OperatorNode::OP_IN;
 				break;
-			case GDScriptTokenizer::TK_OP_EQUAL:
+			case CScriptTokenizer::TK_OP_EQUAL:
 				op = OperatorNode::OP_EQUAL;
 				break;
-			case GDScriptTokenizer::TK_OP_NOT_EQUAL:
+			case CScriptTokenizer::TK_OP_NOT_EQUAL:
 				op = OperatorNode::OP_NOT_EQUAL;
 				break;
-			case GDScriptTokenizer::TK_OP_LESS:
+			case CScriptTokenizer::TK_OP_LESS:
 				op = OperatorNode::OP_LESS;
 				break;
-			case GDScriptTokenizer::TK_OP_LESS_EQUAL:
+			case CScriptTokenizer::TK_OP_LESS_EQUAL:
 				op = OperatorNode::OP_LESS_EQUAL;
 				break;
-			case GDScriptTokenizer::TK_OP_GREATER:
+			case CScriptTokenizer::TK_OP_GREATER:
 				op = OperatorNode::OP_GREATER;
 				break;
-			case GDScriptTokenizer::TK_OP_GREATER_EQUAL:
+			case CScriptTokenizer::TK_OP_GREATER_EQUAL:
 				op = OperatorNode::OP_GREATER_EQUAL;
 				break;
-			case GDScriptTokenizer::TK_OP_AND:
+			case CScriptTokenizer::TK_OP_AND:
 				op = OperatorNode::OP_AND;
 				break;
-			case GDScriptTokenizer::TK_OP_OR:
+			case CScriptTokenizer::TK_OP_OR:
 				op = OperatorNode::OP_OR;
 				break;
-			case GDScriptTokenizer::TK_OP_ADD:
+			case CScriptTokenizer::TK_OP_ADD:
 				op = OperatorNode::OP_ADD;
 				break;
-			case GDScriptTokenizer::TK_OP_SUB:
+			case CScriptTokenizer::TK_OP_SUB:
 				op = OperatorNode::OP_SUB;
 				break;
-			case GDScriptTokenizer::TK_OP_MUL:
+			case CScriptTokenizer::TK_OP_MUL:
 				op = OperatorNode::OP_MUL;
 				break;
-			case GDScriptTokenizer::TK_OP_DIV:
+			case CScriptTokenizer::TK_OP_DIV:
 				op = OperatorNode::OP_DIV;
 				break;
-			case GDScriptTokenizer::TK_OP_MOD:
+			case CScriptTokenizer::TK_OP_MOD:
 				op = OperatorNode::OP_MOD;
 				break;
-			//case GDScriptTokenizer::TK_OP_NEG: op=OperatorNode::OP_NEG ; break;
-			case GDScriptTokenizer::TK_OP_SHIFT_LEFT:
+			//case CScriptTokenizer::TK_OP_NEG: op=OperatorNode::OP_NEG ; break;
+			case CScriptTokenizer::TK_OP_SHIFT_LEFT:
 				op = OperatorNode::OP_SHIFT_LEFT;
 				break;
-			case GDScriptTokenizer::TK_OP_SHIFT_RIGHT:
+			case CScriptTokenizer::TK_OP_SHIFT_RIGHT:
 				op = OperatorNode::OP_SHIFT_RIGHT;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN: {
+			case CScriptTokenizer::TK_OP_ASSIGN: {
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN;
 
-				if (tokenizer->get_token(1) == GDScriptTokenizer::TK_CURSOR) {
+				if (tokenizer->get_token(1) == CScriptTokenizer::TK_CURSOR) {
 					//code complete assignment
 					completion_type = COMPLETION_ASSIGN;
 					completion_node = expr;
@@ -1361,52 +1361,52 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 				}
 
 			} break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_ADD:
+			case CScriptTokenizer::TK_OP_ASSIGN_ADD:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_ADD;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_SUB:
+			case CScriptTokenizer::TK_OP_ASSIGN_SUB:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SUB;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_MUL:
+			case CScriptTokenizer::TK_OP_ASSIGN_MUL:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MUL;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_DIV:
+			case CScriptTokenizer::TK_OP_ASSIGN_DIV:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_DIV;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_MOD:
+			case CScriptTokenizer::TK_OP_ASSIGN_MOD:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_MOD;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
+			case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_LEFT:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_LEFT;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
+			case CScriptTokenizer::TK_OP_ASSIGN_SHIFT_RIGHT:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_SHIFT_RIGHT;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
+			case CScriptTokenizer::TK_OP_ASSIGN_BIT_AND:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_AND;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
+			case CScriptTokenizer::TK_OP_ASSIGN_BIT_OR:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_OR;
 				break;
-			case GDScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
+			case CScriptTokenizer::TK_OP_ASSIGN_BIT_XOR:
 				_VALIDATE_ASSIGN op = OperatorNode::OP_ASSIGN_BIT_XOR;
 				break;
-			case GDScriptTokenizer::TK_OP_BIT_AND:
+			case CScriptTokenizer::TK_OP_BIT_AND:
 				op = OperatorNode::OP_BIT_AND;
 				break;
-			case GDScriptTokenizer::TK_OP_BIT_OR:
+			case CScriptTokenizer::TK_OP_BIT_OR:
 				op = OperatorNode::OP_BIT_OR;
 				break;
-			case GDScriptTokenizer::TK_OP_BIT_XOR:
+			case CScriptTokenizer::TK_OP_BIT_XOR:
 				op = OperatorNode::OP_BIT_XOR;
 				break;
-			case GDScriptTokenizer::TK_PR_IS:
+			case CScriptTokenizer::TK_PR_IS:
 				op = OperatorNode::OP_IS;
 				break;
-			case GDScriptTokenizer::TK_CF_IF:
+			case CScriptTokenizer::TK_CF_IF:
 				op = OperatorNode::OP_TERNARY_IF;
 				break;
-			case GDScriptTokenizer::TK_CF_ELSE:
+			case CScriptTokenizer::TK_CF_ELSE:
 				op = OperatorNode::OP_TERNARY_ELSE;
 				break;
 			default:
@@ -1575,7 +1575,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 					break;
 
 				default: {
-					_set_error("GDScriptParser bug, invalid operator in expression: " + itos(expression[i].op));
+					_set_error("CScriptParser bug, invalid operator in expression: " + itos(expression[i].op));
 					return nullptr;
 				}
 			}
@@ -1714,7 +1714,7 @@ GDScriptParser::Node *GDScriptParser::_parse_expression(Node *p_parent, bool p_s
 	return expression[0].node;
 }
 
-GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to_const) {
+CScriptParser::Node *CScriptParser::_reduce_expression(Node *p_node, bool p_to_const) {
 	switch (p_node->type) {
 		case Node::TYPE_BUILT_IN_FUNCTION: {
 			//many may probably be optimizable
@@ -1807,7 +1807,7 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 
 			} else if (op->op == OperatorNode::OP_CALL) {
 				//can reduce base type constructors
-				if ((op->arguments[0]->type == Node::TYPE_TYPE || (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && GDScriptFunctions::is_deterministic(static_cast<BuiltInFunctionNode *>(op->arguments[0])->function))) && last_not_constant == 0) {
+				if ((op->arguments[0]->type == Node::TYPE_TYPE || (op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && CScriptFunctions::is_deterministic(static_cast<BuiltInFunctionNode *>(op->arguments[0])->function))) && last_not_constant == 0) {
 					//native type constructor or intrinsic function
 					const Variant **vptr = nullptr;
 					Vector<Variant *> ptrs;
@@ -1829,8 +1829,8 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 						v = Variant::construct(tn->vtype, vptr, ptrs.size(), ce);
 
 					} else {
-						GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
-						GDScriptFunctions::call(func, vptr, ptrs.size(), v, ce);
+						CScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+						CScriptFunctions::call(func, vptr, ptrs.size(), v, ce);
 					}
 
 					if (ce.error != Variant::CallError::CALL_OK) {
@@ -1840,8 +1840,8 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 							errwhere = "'" + Variant::get_type_name(tn->vtype) + "' constructor";
 
 						} else {
-							GDScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
-							errwhere = String("'") + GDScriptFunctions::get_func_name(func) + "' intrinsic function";
+							CScriptFunctions::Function func = static_cast<BuiltInFunctionNode *>(op->arguments[0])->function;
+							errwhere = String("'") + CScriptFunctions::get_func_name(func) + "' intrinsic function";
 						}
 
 						switch (ce.error) {
@@ -2083,7 +2083,7 @@ GDScriptParser::Node *GDScriptParser::_reduce_expression(Node *p_node, bool p_to
 	}
 }
 
-GDScriptParser::Node *GDScriptParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
+CScriptParser::Node *CScriptParser::_parse_and_reduce_expression(Node *p_parent, bool p_static, bool p_reduce_const, bool p_allow_assign) {
 	Node *expr = _parse_expression(p_parent, p_static, p_allow_assign, p_reduce_const);
 	if (!expr || error_set) {
 		return nullptr;
@@ -2095,7 +2095,7 @@ GDScriptParser::Node *GDScriptParser::_parse_and_reduce_expression(Node *p_paren
 	return expr;
 }
 
-bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
+bool CScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
 	if (p_value.get_type() == Variant::ARRAY) {
 		Array arr = p_value;
 		for (int i = 0; i < arr.size(); i++) {
@@ -2130,56 +2130,56 @@ bool GDScriptParser::_reduce_export_var_type(Variant &p_value, int p_line) {
 	return false;
 }
 
-bool GDScriptParser::_recover_from_completion() {
+bool CScriptParser::_recover_from_completion() {
 	if (!completion_found) {
 		return false; //can't recover if no completion
 	}
 	//skip stuff until newline
-	while (tokenizer->get_token() != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token() != GDScriptTokenizer::TK_EOF && tokenizer->get_token() != GDScriptTokenizer::TK_ERROR) {
+	while (tokenizer->get_token() != CScriptTokenizer::TK_NEWLINE && tokenizer->get_token() != CScriptTokenizer::TK_EOF && tokenizer->get_token() != CScriptTokenizer::TK_ERROR) {
 		tokenizer->advance();
 	}
 	completion_found = false;
 	error_set = false;
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_ERROR) {
 		error_set = true;
 	}
 
 	return true;
 }
 
-GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
+CScriptParser::PatternNode *CScriptParser::_parse_pattern(bool p_static) {
 	PatternNode *pattern = alloc_node<PatternNode>();
 
-	GDScriptTokenizer::Token token = tokenizer->get_token();
+	CScriptTokenizer::Token token = tokenizer->get_token();
 	if (error_set) {
 		return nullptr;
 	}
 
-	if (token == GDScriptTokenizer::TK_EOF) {
+	if (token == CScriptTokenizer::TK_EOF) {
 		return nullptr;
 	}
 
 	switch (token) {
 		// array
-		case GDScriptTokenizer::TK_BRACKET_OPEN: {
+		case CScriptTokenizer::TK_BRACKET_OPEN: {
 			tokenizer->advance();
-			pattern->pt_type = GDScriptParser::PatternNode::PT_ARRAY;
+			pattern->pt_type = CScriptParser::PatternNode::PT_ARRAY;
 			while (true) {
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == CScriptTokenizer::TK_PERIOD) {
 					// match everything
 					tokenizer->advance(2);
 					PatternNode *sub_pattern = alloc_node<PatternNode>();
-					sub_pattern->pt_type = GDScriptParser::PatternNode::PT_IGNORE_REST;
+					sub_pattern->pt_type = CScriptParser::PatternNode::PT_IGNORE_REST;
 					pattern->array.push_back(sub_pattern);
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == CScriptTokenizer::TK_BRACKET_CLOSE) {
 						tokenizer->advance(2);
 						break;
-					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+					} else if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_CLOSE) {
 						tokenizer->advance(1);
 						break;
 					} else {
@@ -2195,10 +2195,10 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 
 				pattern->array.push_back(sub_pattern);
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 					tokenizer->advance();
 					continue;
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				} else {
@@ -2208,13 +2208,13 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 			}
 		} break;
 		// bind
-		case GDScriptTokenizer::TK_PR_VAR: {
+		case CScriptTokenizer::TK_PR_VAR: {
 			tokenizer->advance();
 			if (!tokenizer->is_token_literal()) {
 				_set_error("Expected identifier for binding variable name.");
 				return nullptr;
 			}
-			pattern->pt_type = GDScriptParser::PatternNode::PT_BIND;
+			pattern->pt_type = CScriptParser::PatternNode::PT_BIND;
 			pattern->bind = tokenizer->get_token_literal();
 			// Check if variable name is already used
 			BlockNode *bl = current_block;
@@ -2232,25 +2232,25 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 			tokenizer->advance();
 		} break;
 		// dictionary
-		case GDScriptTokenizer::TK_CURLY_BRACKET_OPEN: {
+		case CScriptTokenizer::TK_CURLY_BRACKET_OPEN: {
 			tokenizer->advance();
-			pattern->pt_type = GDScriptParser::PatternNode::PT_DICTIONARY;
+			pattern->pt_type = CScriptParser::PatternNode::PT_DICTIONARY;
 			while (true) {
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == GDScriptTokenizer::TK_PERIOD) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD && tokenizer->get_token(1) == CScriptTokenizer::TK_PERIOD) {
 					// match everything
 					tokenizer->advance(2);
 					PatternNode *sub_pattern = alloc_node<PatternNode>();
 					sub_pattern->pt_type = PatternNode::PT_IGNORE_REST;
 					pattern->array.push_back(sub_pattern);
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA && tokenizer->get_token(1) == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 						tokenizer->advance(2);
 						break;
-					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 						tokenizer->advance(1);
 						break;
 					} else {
@@ -2265,12 +2265,12 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 					return nullptr;
 				}
 
-				if (key->type != GDScriptParser::Node::TYPE_CONSTANT) {
+				if (key->type != CScriptParser::Node::TYPE_CONSTANT) {
 					_set_error("Not a constant expression as key");
 					return nullptr;
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
 					tokenizer->advance();
 
 					PatternNode *value = _parse_pattern(p_static);
@@ -2284,10 +2284,10 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 					pattern->dictionary.insert(static_cast<ConstantNode *>(key), NULL);
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 					tokenizer->advance();
 					continue;
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 					tokenizer->advance();
 					break;
 				} else {
@@ -2296,7 +2296,7 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 				}
 			}
 		} break;
-		case GDScriptTokenizer::TK_WILDCARD: {
+		case CScriptTokenizer::TK_WILDCARD: {
 			tokenizer->advance();
 			pattern->pt_type = PatternNode::PT_WILDCARD;
 		} break;
@@ -2340,7 +2340,7 @@ GDScriptParser::PatternNode *GDScriptParser::_parse_pattern(bool p_static) {
 	return pattern;
 }
 
-void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static) {
+void CScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBranchNode *> &p_branches, bool p_static) {
 	IndentLevel current_level = indent_level.back()->get();
 
 	p_block->has_return = true;
@@ -2348,11 +2348,11 @@ void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBran
 	bool catch_all_appeared = false;
 
 	while (true) {
-		while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
+		while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE && _parse_newline()) {
 			;
 		}
 
-		// GDScriptTokenizer::Token token = tokenizer->get_token();
+		// CScriptTokenizer::Token token = tokenizer->get_token();
 		if (error_set) {
 			return;
 		}
@@ -2380,12 +2380,12 @@ void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBran
 #ifdef DEBUG_ENABLED
 		// Branches after a wildcard or binding are unreachable
 		if (catch_all_appeared && !current_function->has_unreachable_code) {
-			_add_warning(GDScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
+			_add_warning(CScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
 			current_function->has_unreachable_code = true;
 		}
 #endif
 
-		while (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+		while (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 			tokenizer->advance();
 			branch->patterns.push_back(_parse_pattern(p_static));
 			if (!branch->patterns[branch->patterns.size() - 1]) {
@@ -2426,7 +2426,7 @@ void GDScriptParser::_parse_pattern_block(BlockNode *p_block, Vector<PatternBran
 	}
 }
 
-void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings) {
+void CScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_match, Node *&p_resulting_node, Map<StringName, Node *> &p_bindings) {
 	const DataType &to_match_type = p_node_to_match->get_datatype();
 
 	switch (p_pattern->pt_type) {
@@ -2448,7 +2448,7 @@ void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_m
 			} else {
 				// runtime typecheck
 				BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
-				typeof_node->function = GDScriptFunctions::TYPE_OF;
+				typeof_node->function = CScriptFunctions::TYPE_OF;
 
 				OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 				typeof_match_value->op = OperatorNode::OP_CALL;
@@ -2516,7 +2516,7 @@ void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_m
 				} else {
 					// runtime typecheck
 					BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
-					typeof_node->function = GDScriptFunctions::TYPE_OF;
+					typeof_node->function = CScriptFunctions::TYPE_OF;
 
 					OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 					typeof_match_value->op = OperatorNode::OP_CALL;
@@ -2608,7 +2608,7 @@ void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_m
 				} else {
 					// runtime typecheck
 					BuiltInFunctionNode *typeof_node = alloc_node<BuiltInFunctionNode>();
-					typeof_node->function = GDScriptFunctions::TYPE_OF;
+					typeof_node->function = CScriptFunctions::TYPE_OF;
 
 					OperatorNode *typeof_match_value = alloc_node<OperatorNode>();
 					typeof_match_value->op = OperatorNode::OP_CALL;
@@ -2708,7 +2708,7 @@ void GDScriptParser::_generate_pattern(PatternNode *p_pattern, Node *p_node_to_m
 	}
 }
 
-void GDScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
+void CScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
 	IdentifierNode *id = alloc_node<IdentifierNode>();
 	id->name = "#match_value";
 	id->line = p_match_statement->line;
@@ -2805,7 +2805,7 @@ void GDScriptParser::_transform_match_statment(MatchNode *p_match_statement) {
 	}
 }
 
-void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
+void CScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 	IndentLevel current_level = indent_level.back()->get();
 
 #ifdef DEBUG_ENABLED
@@ -2833,7 +2833,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 		}
 		is_first_line = false;
 
-		GDScriptTokenizer::Token token = tokenizer->get_token();
+		CScriptTokenizer::Token token = tokenizer->get_token();
 		if (error_set) {
 			return;
 		}
@@ -2852,30 +2852,30 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 #ifdef DEBUG_ENABLED
 		switch (token) {
-			case GDScriptTokenizer::TK_EOF:
-			case GDScriptTokenizer::TK_ERROR:
-			case GDScriptTokenizer::TK_NEWLINE:
-			case GDScriptTokenizer::TK_CF_PASS: {
+			case CScriptTokenizer::TK_EOF:
+			case CScriptTokenizer::TK_ERROR:
+			case CScriptTokenizer::TK_NEWLINE:
+			case CScriptTokenizer::TK_CF_PASS: {
 				// will check later
 			} break;
 			default: {
 				if (p_block->has_return && !current_function->has_unreachable_code) {
-					_add_warning(GDScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
+					_add_warning(CScriptWarning::UNREACHABLE_CODE, -1, current_function->name.operator String());
 					current_function->has_unreachable_code = true;
 				}
 			} break;
 		}
 #endif // DEBUG_ENABLED
 		switch (token) {
-			case GDScriptTokenizer::TK_EOF:
+			case CScriptTokenizer::TK_EOF:
 				p_block->end_line = tokenizer->get_token_line();
-			case GDScriptTokenizer::TK_ERROR: {
+			case CScriptTokenizer::TK_ERROR: {
 				return; //go back
 
 				//end of file!
 
 			} break;
-			case GDScriptTokenizer::TK_NEWLINE: {
+			case CScriptTokenizer::TK_NEWLINE: {
 				int line = tokenizer->get_token_line();
 
 				if (!_parse_newline()) {
@@ -2892,19 +2892,19 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				p_block->statements.push_back(nl2);
 
 			} break;
-			case GDScriptTokenizer::TK_CF_PASS: {
-				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_SEMICOLON && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE && tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF) {
+			case CScriptTokenizer::TK_CF_PASS: {
+				if (tokenizer->get_token(1) != CScriptTokenizer::TK_SEMICOLON && tokenizer->get_token(1) != CScriptTokenizer::TK_NEWLINE && tokenizer->get_token(1) != CScriptTokenizer::TK_EOF) {
 					_set_error("Expected \";\" or a line break.");
 					return;
 				}
 				_mark_line_as_safe(tokenizer->get_token_line());
 				tokenizer->advance();
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_SEMICOLON) {
 					// Ignore semicolon after 'pass'.
 					tokenizer->advance();
 				}
 			} break;
-			case GDScriptTokenizer::TK_PR_VAR: {
+			case CScriptTokenizer::TK_PR_VAR: {
 				// Variable declaration and (eventual) initialization.
 
 				tokenizer->advance();
@@ -2940,8 +2940,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				Node *assigned = nullptr;
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
-					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 						lv->datatype = DataType();
 						lv->datatype.infer_type = true;
 						tokenizer->advance();
@@ -2951,7 +2951,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 					}
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_OP_ASSIGN) {
 					tokenizer->advance();
 					Node *subexpr = _parse_and_reduce_expression(p_block, p_static);
 					if (!subexpr) {
@@ -2989,7 +2989,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				}
 
 			} break;
-			case GDScriptTokenizer::TK_CF_IF: {
+			case CScriptTokenizer::TK_CF_IF: {
 				tokenizer->advance();
 
 				Node *condition = _parse_and_reduce_expression(p_block, p_static);
@@ -3030,7 +3030,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				bool have_else = false;
 
 				while (true) {
-					while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE && _parse_newline()) {
+					while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE && _parse_newline()) {
 						;
 					}
 
@@ -3039,7 +3039,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 						return;
 					}
 
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELIF) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_CF_ELIF) {
 						if (indent_level.back()->get().indent > current_level.indent) {
 							_set_error("Invalid indentation.");
 							return;
@@ -3086,7 +3086,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 						all_have_return = all_have_return && cf_else->body->has_return;
 
-					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CF_ELSE) {
+					} else if (tokenizer->get_token() == CScriptTokenizer::TK_CF_ELSE) {
 						if (indent_level.back()->get().indent > current_level.indent) {
 							_set_error("Invalid indentation.");
 							return;
@@ -3124,7 +3124,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				p_block->has_return = all_have_return && have_else;
 
 			} break;
-			case GDScriptTokenizer::TK_CF_WHILE: {
+			case CScriptTokenizer::TK_CF_WHILE: {
 				tokenizer->advance();
 				Node *condition2 = _parse_and_reduce_expression(p_block, p_static);
 				if (!condition2) {
@@ -3159,7 +3159,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				}
 				p_block->statements.push_back(cf_while);
 			} break;
-			case GDScriptTokenizer::TK_CF_FOR: {
+			case CScriptTokenizer::TK_CF_FOR: {
 				tokenizer->advance();
 
 				if (!tokenizer->is_token_literal(0, true)) {
@@ -3171,7 +3171,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 #ifdef DEBUG_ENABLED
 				for (int j = 0; j < current_class->variables.size(); j++) {
 					if (current_class->variables[j].identifier == id->name) {
-						_add_warning(GDScriptWarning::SHADOWED_VARIABLE, id->line, id->name, itos(current_class->variables[j].line));
+						_add_warning(CScriptWarning::SHADOWED_VARIABLE, id->line, id->name, itos(current_class->variables[j].line));
 					}
 				}
 #endif // DEBUG_ENABLED
@@ -3187,7 +3187,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_IN) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_OP_IN) {
 					_set_error("\"in\" expected after identifier.");
 					return;
 				}
@@ -3206,7 +3206,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				if (container->type == Node::TYPE_OPERATOR) {
 					OperatorNode *op = static_cast<OperatorNode *>(container);
-					if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode *>(op->arguments[0])->function == GDScriptFunctions::GEN_RANGE) {
+					if (op->op == OperatorNode::OP_CALL && op->arguments[0]->type == Node::TYPE_BUILT_IN_FUNCTION && static_cast<BuiltInFunctionNode *>(op->arguments[0])->function == CScriptFunctions::GEN_RANGE) {
 						//iterating a range, so see if range() can be optimized without allocating memory, by replacing it by vectors (which can work as iterable too!)
 
 						Vector<Node *> args;
@@ -3315,7 +3315,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				}
 				p_block->statements.push_back(cf_for);
 			} break;
-			case GDScriptTokenizer::TK_CF_CONTINUE: {
+			case CScriptTokenizer::TK_CF_CONTINUE: {
 				BlockNode *upper_block = p_block;
 				bool is_continue_valid = false;
 				while (upper_block) {
@@ -3341,7 +3341,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_CF_BREAK: {
+			case CScriptTokenizer::TK_CF_BREAK: {
 				BlockNode *upper_block = p_block;
 				bool is_break_valid = false;
 				while (upper_block) {
@@ -3367,13 +3367,13 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_CF_RETURN: {
+			case CScriptTokenizer::TK_CF_RETURN: {
 				tokenizer->advance();
 				ControlFlowNode *cf_return = alloc_node<ControlFlowNode>();
 				cf_return->cf_type = ControlFlowNode::CF_RETURN;
 				cf_return->line = tokenizer->get_token_line(-1);
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_SEMICOLON || tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_SEMICOLON || tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE || tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 					//expect end of statement
 					p_block->statements.push_back(cf_return);
 					if (!_end_statement()) {
@@ -3398,7 +3398,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				p_block->has_return = true;
 
 			} break;
-			case GDScriptTokenizer::TK_CF_MATCH: {
+			case CScriptTokenizer::TK_CF_MATCH: {
 				tokenizer->advance();
 
 				MatchNode *match_node = alloc_node<MatchNode>();
@@ -3442,10 +3442,10 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 				_end_statement();
 			} break;
-			case GDScriptTokenizer::TK_PR_ASSERT: {
+			case CScriptTokenizer::TK_PR_ASSERT: {
 				tokenizer->advance();
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 					_set_error("Expected '(' after assert");
 					return;
 				}
@@ -3484,7 +3484,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_PR_BREAKPOINT: {
+			case CScriptTokenizer::TK_PR_BREAKPOINT: {
 				tokenizer->advance();
 				BreakpointNode *bn = alloc_node<BreakpointNode>();
 				p_block->statements.push_back(bn);
@@ -3505,7 +3505,7 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 				p_block->statements.push_back(expression);
 				if (!_end_statement()) {
 					// Attempt to guess a better error message if the user "retypes" a variable
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON && tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_COLON && tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 						_set_error("Unexpected ':=', use '=' instead. Expected end of statement after expression.");
 					} else {
 						_set_error(vformat("Expected end of statement after expression, got %s instead.", tokenizer->get_token_name(tokenizer->get_token())));
@@ -3518,8 +3518,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 	}
 }
 
-bool GDScriptParser::_parse_newline() {
-	if (tokenizer->get_token(1) != GDScriptTokenizer::TK_EOF && tokenizer->get_token(1) != GDScriptTokenizer::TK_NEWLINE) {
+bool CScriptParser::_parse_newline() {
+	if (tokenizer->get_token(1) != CScriptTokenizer::TK_EOF && tokenizer->get_token(1) != CScriptTokenizer::TK_NEWLINE) {
 		IndentLevel current_level = indent_level.back()->get();
 		int indent = tokenizer->get_token_line_indent();
 		int tabs = tokenizer->get_token_line_tab_indent();
@@ -3567,7 +3567,7 @@ bool GDScriptParser::_parse_newline() {
 	return true;
 }
 
-void GDScriptParser::_parse_extends(ClassNode *p_class) {
+void CScriptParser::_parse_extends(ClassNode *p_class) {
 	if (p_class->extends_used) {
 		_set_error("\"extends\" can only be present once per script.");
 		return;
@@ -3582,14 +3582,14 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 
 	tokenizer->advance();
 
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type() == Variant::OBJECT) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE && tokenizer->get_token_type() == Variant::OBJECT) {
 		p_class->extends_class.push_back(Variant::get_type_name(Variant::OBJECT));
 		tokenizer->advance();
 		return;
 	}
 
 	// see if inheritance happens from a file
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT) {
 		Variant constant = tokenizer->get_token_constant();
 		if (constant.get_type() != Variant::STRING) {
 			_set_error("\"extends\" constant must be a string.");
@@ -3606,7 +3606,7 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 		}
 		dependencies.push_back(parent);
 
-		if (tokenizer->get_token() != GDScriptTokenizer::TK_PERIOD) {
+		if (tokenizer->get_token() != CScriptTokenizer::TK_PERIOD) {
 			return;
 		} else {
 			tokenizer->advance();
@@ -3615,13 +3615,13 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 
 	while (true) {
 		switch (tokenizer->get_token()) {
-			case GDScriptTokenizer::TK_IDENTIFIER: {
+			case CScriptTokenizer::TK_IDENTIFIER: {
 				StringName identifier = tokenizer->get_token_identifier();
 				p_class->extends_class.push_back(identifier);
 			} break;
 
-			case GDScriptTokenizer::TK_CURSOR:
-			case GDScriptTokenizer::TK_PERIOD:
+			case CScriptTokenizer::TK_CURSOR:
+			case CScriptTokenizer::TK_PERIOD:
 				break;
 
 			default: {
@@ -3633,10 +3633,10 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 		tokenizer->advance(1);
 
 		switch (tokenizer->get_token()) {
-			case GDScriptTokenizer::TK_IDENTIFIER:
-			case GDScriptTokenizer::TK_PERIOD:
+			case CScriptTokenizer::TK_IDENTIFIER:
+			case CScriptTokenizer::TK_PERIOD:
 				continue;
-			case GDScriptTokenizer::TK_CURSOR:
+			case CScriptTokenizer::TK_CURSOR:
 				completion_type = COMPLETION_EXTENDS;
 				completion_class = current_class;
 				completion_function = current_function;
@@ -3651,11 +3651,11 @@ void GDScriptParser::_parse_extends(ClassNode *p_class) {
 	}
 }
 
-void GDScriptParser::_parse_class(ClassNode *p_class) {
+void CScriptParser::_parse_class(ClassNode *p_class) {
 	IndentLevel current_level = indent_level.back()->get();
 
 	while (true) {
-		GDScriptTokenizer::Token token = tokenizer->get_token();
+		CScriptTokenizer::Token token = tokenizer->get_token();
 		if (error_set) {
 			return;
 		}
@@ -3666,16 +3666,16 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 		}
 
 		switch (token) {
-			case GDScriptTokenizer::TK_CURSOR: {
+			case CScriptTokenizer::TK_CURSOR: {
 				tokenizer->advance();
 			} break;
-			case GDScriptTokenizer::TK_EOF:
+			case CScriptTokenizer::TK_EOF:
 				p_class->end_line = tokenizer->get_token_line();
-			case GDScriptTokenizer::TK_ERROR: {
+			case CScriptTokenizer::TK_ERROR: {
 				return; //go back
 				//end of file!
 			} break;
-			case GDScriptTokenizer::TK_NEWLINE: {
+			case CScriptTokenizer::TK_NEWLINE: {
 				if (!_parse_newline()) {
 					if (!error_set) {
 						p_class->end_line = tokenizer->get_token_line();
@@ -3683,7 +3683,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_PR_EXTENDS: {
+			case CScriptTokenizer::TK_PR_EXTENDS: {
 				_mark_line_as_safe(tokenizer->get_token_line());
 				_parse_extends(p_class);
 				if (error_set) {
@@ -3695,7 +3695,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				}
 
 			} break;
-			case GDScriptTokenizer::TK_PR_CLASS_NAME: {
+			case CScriptTokenizer::TK_PR_CLASS_NAME: {
 				_mark_line_as_safe(tokenizer->get_token_line());
 				if (p_class->owner) {
 					_set_error("\"class_name\" is only valid for the main class namespace.");
@@ -3705,7 +3705,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					_set_error("\"class_name\" isn't allowed in built-in scripts.");
 					return;
 				}
-				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token(1) != CScriptTokenizer::TK_IDENTIFIER) {
 					_set_error("\"class_name\" syntax: \"class_name <UniqueName>\"");
 					return;
 				}
@@ -3739,10 +3739,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				tokenizer->advance(2);
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 					tokenizer->advance();
 
-					if ((tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING)) {
+					if ((tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING)) {
 #ifdef TOOLS_ENABLED
 						if (Engine::get_singleton()->is_editor_hint()) {
 							Variant constant = tokenizer->get_token_constant();
@@ -3764,13 +3764,13 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						return;
 					}
 
-				} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT) {
+				} else if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT) {
 					_set_error("The class icon must be separated by a comma.");
 					return;
 				}
 
 			} break;
-			case GDScriptTokenizer::TK_PR_TOOL: {
+			case CScriptTokenizer::TK_PR_TOOL: {
 				if (p_class->tool) {
 					_set_error("The \"tool\" keyword can only be present once per script.");
 					return;
@@ -3780,12 +3780,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				tokenizer->advance();
 
 			} break;
-			case GDScriptTokenizer::TK_PR_CLASS: {
+			case CScriptTokenizer::TK_PR_CLASS: {
 				//class inside class :D
 
 				StringName name;
 
-				if (tokenizer->get_token(1) != GDScriptTokenizer::TK_IDENTIFIER) {
+				if (tokenizer->get_token(1) != CScriptTokenizer::TK_IDENTIFIER) {
 					_set_error("\"class\" syntax: \"class <Name>:\" or \"class <Name> extends <BaseClass>:\"");
 					return;
 				}
@@ -3833,7 +3833,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				p_class->subclasses.push_back(newclass);
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_EXTENDS) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PR_EXTENDS) {
 					_parse_extends(newclass);
 					if (error_set) {
 						return;
@@ -3850,25 +3850,25 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 			} break;
 			/* this is for functions....
-			case GDScriptTokenizer::TK_CF_PASS: {
+			case CScriptTokenizer::TK_CF_PASS: {
 
 				tokenizer->advance(1);
 			} break;
 			*/
-			case GDScriptTokenizer::TK_PR_STATIC: {
+			case CScriptTokenizer::TK_PR_STATIC: {
 				tokenizer->advance();
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 					_set_error("Expected \"func\".");
 					return;
 				}
 
 				FALLTHROUGH;
 			}
-			case GDScriptTokenizer::TK_PR_FUNCTION: {
+			case CScriptTokenizer::TK_PR_FUNCTION: {
 				bool _static = false;
 				pending_newline = -1;
 
-				if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_STATIC) {
+				if (tokenizer->get_token(-1) == CScriptTokenizer::TK_PR_STATIC) {
 					_static = true;
 				}
 
@@ -3896,21 +3896,21 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 #ifdef DEBUG_ENABLED
 				if (p_class->constant_expressions.has(name)) {
-					_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
+					_add_warning(CScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
 				}
 				for (int i = 0; i < p_class->variables.size(); i++) {
 					if (p_class->variables[i].identifier == name) {
-						_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_VARIABLE, -1, name);
+						_add_warning(CScriptWarning::FUNCTION_CONFLICTS_VARIABLE, -1, name);
 					}
 				}
 				for (int i = 0; i < p_class->subclasses.size(); i++) {
 					if (p_class->subclasses[i]->name == name) {
-						_add_warning(GDScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
+						_add_warning(CScriptWarning::FUNCTION_CONFLICTS_CONSTANT, -1, name);
 					}
 				}
 #endif // DEBUG_ENABLED
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 					_set_error("Expected \"(\" after the identifier (syntax: \"func <identifier>([arguments]):\" ).");
 					return;
 				}
@@ -3926,16 +3926,16 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				int fnline = tokenizer->get_token_line();
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 					//has arguments
 					bool defaulting = false;
 					while (true) {
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 							continue;
 						}
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_VAR) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_PR_VAR) {
 							tokenizer->advance(); //var before the identifier is allowed
 						}
 
@@ -3959,8 +3959,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						tokenizer->advance();
 
 						DataType argtype;
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
-							if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
+							if (tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 								argtype.infer_type = true;
 								tokenizer->advance();
 							} else if (!_parse_type(argtype)) {
@@ -3970,14 +3970,14 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						}
 						argument_types.push_back(argtype);
 
-						if (defaulting && tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
+						if (defaulting && tokenizer->get_token() != CScriptTokenizer::TK_OP_ASSIGN) {
 							_set_error("Default parameter expected.");
 							return;
 						}
 
 						//tokenizer->advance();
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_OP_ASSIGN) {
 							defaulting = true;
 							tokenizer->advance(1);
 							Node *defval = _parse_and_reduce_expression(p_class, _static);
@@ -4004,14 +4004,14 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							default_values.push_back(on);
 						}
 
-						while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+						while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 						}
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 							tokenizer->advance();
 							continue;
-						} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						} else if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 							_set_error("Expected \",\" or \")\".");
 							return;
 						}
@@ -4053,15 +4053,15 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						id->name = "_init";
 						cparent->arguments.push_back(id);
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD) {
 							tokenizer->advance();
-							if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+							if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 								_set_error("Expected \"(\" for parent constructor arguments.");
 								return;
 							}
 							tokenizer->advance();
 
-							if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+							if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 								//has arguments
 								parenthesis++;
 								while (true) {
@@ -4073,10 +4073,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									current_function = nullptr;
 									cparent->arguments.push_back(arg);
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 										tokenizer->advance();
 										continue;
-									} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+									} else if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 										_set_error("Expected \",\" or \")\".");
 										return;
 									}
@@ -4089,7 +4089,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							tokenizer->advance();
 						}
 					} else {
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_PERIOD) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_PERIOD) {
 							_set_error("Parent constructor call found for a class without inheritance.");
 							return;
 						}
@@ -4097,7 +4097,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				}
 
 				DataType return_type;
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_FORWARD_ARROW) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_FORWARD_ARROW) {
 					if (!_parse_type(return_type, true)) {
 						_set_error("Expected a return type for the function.");
 						return;
@@ -4125,7 +4125,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				//arguments
 			} break;
-			case GDScriptTokenizer::TK_PR_SIGNAL: {
+			case CScriptTokenizer::TK_PR_SIGNAL: {
 				_mark_line_as_safe(tokenizer->get_token_line());
 				tokenizer->advance();
 
@@ -4148,15 +4148,15 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 					tokenizer->advance();
 					while (true) {
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 							continue;
 						}
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 							tokenizer->advance();
 							break;
 						}
@@ -4169,13 +4169,13 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						sig.arguments.push_back(tokenizer->get_token_identifier());
 						tokenizer->advance();
 
-						while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+						while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 							tokenizer->advance();
 						}
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 							tokenizer->advance();
-						} else if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+						} else if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 							_set_error("Expected \",\" or \")\" after a \"signal\" parameter identifier.");
 							return;
 						}
@@ -4189,14 +4189,14 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_PR_EXPORT: {
+			case CScriptTokenizer::TK_PR_EXPORT: {
 				tokenizer->advance();
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_OPEN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_OPEN) {
 #define _ADVANCE_AND_CONSUME_NEWLINES \
 	do {                              \
 		tokenizer->advance();         \
-	} while (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE)
+	} while (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE)
 
 					_ADVANCE_AND_CONSUME_NEWLINES;
 					parenthesis++;
@@ -4204,9 +4204,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					String hint_prefix = "";
 					bool is_arrayed = false;
 
-					while (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE &&
+					while (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE &&
 							tokenizer->get_token_type() == Variant::ARRAY &&
-							tokenizer->get_token(1) == GDScriptTokenizer::TK_COMMA) {
+							tokenizer->get_token(1) == CScriptTokenizer::TK_COMMA) {
 						tokenizer->advance(); // Array
 						tokenizer->advance(); // Comma
 						if (is_arrayed) {
@@ -4216,7 +4216,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						}
 					}
 
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_BUILT_IN_TYPE) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_BUILT_IN_TYPE) {
 						Variant::Type type = tokenizer->get_token_type();
 						if (type == Variant::NIL) {
 							_set_error("Can't export null type.");
@@ -4230,20 +4230,20 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						current_export.usage |= PROPERTY_USAGE_SCRIPT_VARIABLE;
 						_ADVANCE_AND_CONSUME_NEWLINES;
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 							// hint expected next!
 							_ADVANCE_AND_CONSUME_NEWLINES;
 
 							switch (type) {
 								case Variant::INT: {
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											WARN_DEPRECATED_MSG("Exporting bit flags hint requires string constants.");
 											break;
 										}
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 											_set_error("Expected \",\" in the bit flags hint.");
 											return;
 										}
@@ -4253,7 +4253,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 										bool first = true;
 										while (true) {
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 												current_export = PropertyInfo();
 												_set_error("Expected a string constant in the named bit flags hint.");
 												return;
@@ -4269,11 +4269,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											current_export.hint_string += c.xml_escape();
 
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
 											}
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
 												_set_error("Expected \")\" or \",\" in the named bit flags hint.");
 												return;
@@ -4284,9 +4284,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_RENDER") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_RENDER") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the layers 2D render hint.");
 											return;
 										}
@@ -4294,9 +4294,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_PHYSICS") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_2D_PHYSICS") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the layers 2D physics hint.");
 											return;
 										}
@@ -4304,9 +4304,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_RENDER") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_RENDER") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the layers 3D render hint.");
 											return;
 										}
@@ -4314,9 +4314,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_PHYSICS") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "LAYERS_3D_PHYSICS") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the layers 3D physics hint.");
 											return;
 										}
@@ -4324,12 +4324,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
 										//enumeration
 										current_export.hint = PROPERTY_HINT_ENUM;
 										bool first = true;
 										while (true) {
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 												current_export = PropertyInfo();
 												_set_error("Expected a string constant in the enumeration hint.");
 												return;
@@ -4345,11 +4345,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											current_export.hint_string += c.xml_escape();
 
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
 											}
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
 												_set_error("Expected \")\" or \",\" in the enumeration hint.");
 												return;
@@ -4364,10 +4364,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									FALLTHROUGH;
 								}
 								case Variant::REAL: {
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EASE") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EASE") {
 										current_export.hint = PROPERTY_HINT_EXP_EASING;
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the hint.");
 											return;
 										}
@@ -4375,13 +4375,13 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									}
 
 									// range
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EXP") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "EXP") {
 										current_export.hint = PROPERTY_HINT_EXP_RANGE;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											break;
-										} else if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+										} else if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 											_set_error("Expected \")\" or \",\" in the exponential range hint.");
 											return;
 										}
@@ -4392,11 +4392,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 									float sign = 1.0;
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_OP_SUB) {
 										sign = -1;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 									}
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 										current_export = PropertyInfo();
 										_set_error("Expected a range in the numeric hint.");
 										return;
@@ -4405,12 +4405,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									current_export.hint_string = rtos(sign * double(tokenizer->get_token_constant()));
 									_ADVANCE_AND_CONSUME_NEWLINES;
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 										current_export.hint_string = "0," + current_export.hint_string;
 										break;
 									}
 
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 										current_export = PropertyInfo();
 										_set_error("Expected \",\" or \")\" in the numeric range hint.");
 										return;
@@ -4419,12 +4419,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									_ADVANCE_AND_CONSUME_NEWLINES;
 
 									sign = 1.0;
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_OP_SUB) {
 										sign = -1;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 									}
 
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 										current_export = PropertyInfo();
 										_set_error("Expected a number as upper bound in the numeric range hint.");
 										return;
@@ -4433,11 +4433,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									current_export.hint_string += "," + rtos(sign * double(tokenizer->get_token_constant()));
 									_ADVANCE_AND_CONSUME_NEWLINES;
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 										break;
 									}
 
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 										current_export = PropertyInfo();
 										_set_error("Expected \",\" or \")\" in the numeric range hint.");
 										return;
@@ -4445,12 +4445,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 									_ADVANCE_AND_CONSUME_NEWLINES;
 									sign = 1.0;
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_SUB) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_OP_SUB) {
 										sign = -1;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 									}
 
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || !tokenizer->get_token_constant().is_num()) {
 										current_export = PropertyInfo();
 										_set_error("Expected a number as step in the numeric range hint.");
 										return;
@@ -4461,12 +4461,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 								} break;
 								case Variant::STRING: {
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_CONSTANT && tokenizer->get_token_constant().get_type() == Variant::STRING) {
 										//enumeration
 										current_export.hint = PROPERTY_HINT_ENUM;
 										bool first = true;
 										while (true) {
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 												current_export = PropertyInfo();
 												_set_error("Expected a string constant in the enumeration hint.");
 												return;
@@ -4481,11 +4481,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 											current_export.hint_string += c.xml_escape();
 											_ADVANCE_AND_CONSUME_NEWLINES;
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												break;
 											}
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 												current_export = PropertyInfo();
 												_set_error("Expected \")\" or \",\" in the enumeration hint.");
 												return;
@@ -4496,15 +4496,15 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "DIR") {
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											current_export.hint = PROPERTY_HINT_DIR;
-										} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+										} else if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 											_ADVANCE_AND_CONSUME_NEWLINES;
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_IDENTIFIER || !(tokenizer->get_token_identifier() == "GLOBAL")) {
 												_set_error("Expected \"GLOBAL\" after comma in the directory hint.");
 												return;
 											}
@@ -4515,7 +4515,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											current_export.hint = PROPERTY_HINT_GLOBAL_DIR;
 											_ADVANCE_AND_CONSUME_NEWLINES;
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 												_set_error("Expected \")\" in the hint.");
 												return;
 											}
@@ -4526,14 +4526,14 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FILE") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FILE") {
 										current_export.hint = PROPERTY_HINT_FILE;
 										_ADVANCE_AND_CONSUME_NEWLINES;
 
-										if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+										if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 											_ADVANCE_AND_CONSUME_NEWLINES;
 
-											if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "GLOBAL") {
+											if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "GLOBAL") {
 												if (!p_class->tool) {
 													_set_error("Global filesystem hints may only be used in tool scripts.");
 													return;
@@ -4541,9 +4541,9 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 												current_export.hint = PROPERTY_HINT_GLOBAL_FILE;
 												_ADVANCE_AND_CONSUME_NEWLINES;
 
-												if (tokenizer->get_token() == GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+												if (tokenizer->get_token() == CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 													break;
-												} else if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+												} else if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 													_ADVANCE_AND_CONSUME_NEWLINES;
 												} else {
 													_set_error("Expected \")\" or \",\" in the hint.");
@@ -4551,7 +4551,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 												}
 											}
 
-											if (tokenizer->get_token() != GDScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
+											if (tokenizer->get_token() != CScriptTokenizer::TK_CONSTANT || tokenizer->get_token_constant().get_type() != Variant::STRING) {
 												if (current_export.hint == PROPERTY_HINT_GLOBAL_FILE) {
 													_set_error("Expected string constant with filter.");
 												} else {
@@ -4563,17 +4563,17 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 											_ADVANCE_AND_CONSUME_NEWLINES;
 										}
 
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the hint.");
 											return;
 										}
 										break;
 									}
 
-									if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "MULTILINE") {
+									if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "MULTILINE") {
 										current_export.hint = PROPERTY_HINT_MULTILINE_TEXT;
 										_ADVANCE_AND_CONSUME_NEWLINES;
-										if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+										if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 											_set_error("Expected \")\" in the hint.");
 											return;
 										}
@@ -4581,7 +4581,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									}
 								} break;
 								case Variant::COLOR: {
-									if (tokenizer->get_token() != GDScriptTokenizer::TK_IDENTIFIER) {
+									if (tokenizer->get_token() != CScriptTokenizer::TK_IDENTIFIER) {
 										current_export = PropertyInfo();
 										_set_error("Color type hint expects RGB or RGBA as hints.");
 										return;
@@ -4628,7 +4628,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						Variant constant = static_cast<ConstantNode *>(subexpr)->value;
 
 						if (constant.get_type() == Variant::OBJECT) {
-							GDScriptNativeClass *native_class = Object::cast_to<GDScriptNativeClass>(constant);
+							CScriptNativeClass *native_class = Object::cast_to<CScriptNativeClass>(constant);
 
 							if (native_class && ClassDB::is_parent_class(native_class->get_name(), "Resource")) {
 								current_export.type = Variant::OBJECT;
@@ -4646,10 +4646,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							// Enumeration
 							bool is_flags = false;
 
-							if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+							if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 								_ADVANCE_AND_CONSUME_NEWLINES;
 
-								if (tokenizer->get_token() == GDScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
+								if (tokenizer->get_token() == CScriptTokenizer::TK_IDENTIFIER && tokenizer->get_token_identifier() == "FLAGS") {
 									is_flags = true;
 									_ADVANCE_AND_CONSUME_NEWLINES;
 								} else {
@@ -4689,7 +4689,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						}
 					}
 
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PARENTHESIS_CLOSE) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PARENTHESIS_CLOSE) {
 						current_export = PropertyInfo();
 						_set_error("Expected \")\" or \",\" after the export hint.");
 						return;
@@ -4710,7 +4710,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 #undef _ADVANCE_AND_CONSUME_NEWLINES
 				}
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPET && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_PUPPETSYNC && tokenizer->get_token() != GDScriptTokenizer::TK_PR_SLAVE) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_ONREADY && tokenizer->get_token() != CScriptTokenizer::TK_PR_REMOTE && tokenizer->get_token() != CScriptTokenizer::TK_PR_MASTER && tokenizer->get_token() != CScriptTokenizer::TK_PR_PUPPET && tokenizer->get_token() != CScriptTokenizer::TK_PR_SYNC && tokenizer->get_token() != CScriptTokenizer::TK_PR_REMOTESYNC && tokenizer->get_token() != CScriptTokenizer::TK_PR_MASTERSYNC && tokenizer->get_token() != CScriptTokenizer::TK_PR_PUPPETSYNC && tokenizer->get_token() != CScriptTokenizer::TK_PR_SLAVE) {
 					current_export = PropertyInfo();
 					_set_error("Expected \"var\", \"onready\", \"remote\", \"master\", \"puppet\", \"sync\", \"remotesync\", \"mastersync\", \"puppetsync\".");
 					return;
@@ -4718,27 +4718,27 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_ONREADY: {
+			case CScriptTokenizer::TK_PR_ONREADY: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR) {
 					_set_error("Expected \"var\".");
 					return;
 				}
 
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_REMOTE: {
+			case CScriptTokenizer::TK_PR_REMOTE: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (current_export.type) {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR) {
 						_set_error("Expected \"var\".");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected \"var\" or \"func\".");
 						return;
 					}
@@ -4747,17 +4747,17 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_MASTER: {
+			case CScriptTokenizer::TK_PR_MASTER: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (current_export.type) {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR) {
 						_set_error("Expected \"var\".");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected \"var\" or \"func\".");
 						return;
 					}
@@ -4766,22 +4766,22 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				rpc_mode = MultiplayerAPI::RPC_MODE_MASTER;
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_SLAVE:
+			case CScriptTokenizer::TK_PR_SLAVE:
 #ifdef DEBUG_ENABLED
-				_add_warning(GDScriptWarning::DEPRECATED_KEYWORD, tokenizer->get_token_line(), "slave", "puppet");
+				_add_warning(CScriptWarning::DEPRECATED_KEYWORD, tokenizer->get_token_line(), "slave", "puppet");
 #endif
 				FALLTHROUGH;
-			case GDScriptTokenizer::TK_PR_PUPPET: {
+			case CScriptTokenizer::TK_PR_PUPPET: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
 				if (current_export.type) {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR) {
 						_set_error("Expected \"var\".");
 						return;
 					}
 
 				} else {
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 						_set_error("Expected \"var\" or \"func\".");
 						return;
 					}
@@ -4790,11 +4790,11 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				rpc_mode = MultiplayerAPI::RPC_MODE_PUPPET;
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_REMOTESYNC:
-			case GDScriptTokenizer::TK_PR_SYNC: {
+			case CScriptTokenizer::TK_PR_REMOTESYNC:
+			case CScriptTokenizer::TK_PR_SYNC: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 					if (current_export.type) {
 						_set_error("Expected \"var\".");
 					} else {
@@ -4806,10 +4806,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				rpc_mode = MultiplayerAPI::RPC_MODE_REMOTESYNC;
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_MASTERSYNC: {
+			case CScriptTokenizer::TK_PR_MASTERSYNC: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 					if (current_export.type) {
 						_set_error("Expected \"var\".");
 					} else {
@@ -4821,10 +4821,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				rpc_mode = MultiplayerAPI::RPC_MODE_MASTERSYNC;
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_PUPPETSYNC: {
+			case CScriptTokenizer::TK_PR_PUPPETSYNC: {
 				//may be fallthrough from export, ignore if so
 				tokenizer->advance();
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != GDScriptTokenizer::TK_PR_FUNCTION) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_PR_VAR && tokenizer->get_token() != CScriptTokenizer::TK_PR_FUNCTION) {
 					if (current_export.type) {
 						_set_error("Expected \"var\".");
 					} else {
@@ -4836,18 +4836,18 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				rpc_mode = MultiplayerAPI::RPC_MODE_PUPPETSYNC;
 				continue;
 			} break;
-			case GDScriptTokenizer::TK_PR_VAR: {
+			case CScriptTokenizer::TK_PR_VAR: {
 				// variable declaration and (eventual) initialization
 
 				ClassNode::Member member;
 
-				bool autoexport = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_EXPORT;
+				bool autoexport = tokenizer->get_token(-1) == CScriptTokenizer::TK_PR_EXPORT;
 				if (current_export.type != Variant::NIL) {
 					member._export = current_export;
 					current_export = PropertyInfo();
 				}
 
-				bool onready = tokenizer->get_token(-1) == GDScriptTokenizer::TK_PR_ONREADY;
+				bool onready = tokenizer->get_token(-1) == CScriptTokenizer::TK_PR_ONREADY;
 
 				tokenizer->advance();
 				if (!tokenizer->is_token_literal(0, true)) {
@@ -4885,13 +4885,13 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 #ifdef DEBUG_ENABLED
 				for (int i = 0; i < current_class->functions.size(); i++) {
 					if (current_class->functions[i]->name == member.identifier) {
-						_add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
+						_add_warning(CScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
 						break;
 					}
 				}
 				for (int i = 0; i < current_class->static_functions.size(); i++) {
 					if (current_class->static_functions[i]->name == member.identifier) {
-						_add_warning(GDScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
+						_add_warning(CScriptWarning::VARIABLE_CONFLICTS_FUNCTION, member.line, member.identifier);
 						break;
 					}
 				}
@@ -4900,8 +4900,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				rpc_mode = MultiplayerAPI::RPC_MODE_DISABLED;
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
-					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 						member.data_type = DataType();
 						member.data_type.infer_type = true;
 						tokenizer->advance();
@@ -4937,7 +4937,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				member.default_value = Variant::construct(member._export.type, nullptr, 0, ce);
 #endif
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_OP_ASSIGN) {
 #ifdef DEBUG_ENABLED
 					int line = tokenizer->get_token_line();
 #endif
@@ -5005,7 +5005,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 									_set_error("Can't convert the provided value to the export type.");
 									return;
 								} else if (!member.data_type.has_type) {
-									_add_warning(GDScriptWarning::EXPORT_HINT_TYPE_MISTMATCH, member.line, Variant::get_type_name(cn->value.get_type()), Variant::get_type_name(member._export.type));
+									_add_warning(CScriptWarning::EXPORT_HINT_TYPE_MISTMATCH, member.line, Variant::get_type_name(cn->value.get_type()), Variant::get_type_name(member._export.type));
 								}
 							}
 						}
@@ -5071,10 +5071,10 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					member.initial_assignment = op;
 				}
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_PR_SETGET) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_PR_SETGET) {
 					tokenizer->advance();
 
-					if (tokenizer->get_token() != GDScriptTokenizer::TK_COMMA) {
+					if (tokenizer->get_token() != CScriptTokenizer::TK_COMMA) {
 						//just comma means using only getter
 						if (!tokenizer->is_token_literal()) {
 							_set_error("Expected an identifier for the setter function after \"setget\".");
@@ -5085,7 +5085,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 						tokenizer->advance();
 					}
 
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 						//there is a getter
 						tokenizer->advance();
 
@@ -5105,7 +5105,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					return;
 				}
 			} break;
-			case GDScriptTokenizer::TK_PR_CONST: {
+			case CScriptTokenizer::TK_PR_CONST: {
 				// constant declaration and initialization
 
 				ClassNode::Constant constant;
@@ -5142,8 +5142,8 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 				tokenizer->advance();
 
-				if (tokenizer->get_token() == GDScriptTokenizer::TK_COLON) {
-					if (tokenizer->get_token(1) == GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() == CScriptTokenizer::TK_COLON) {
+					if (tokenizer->get_token(1) == CScriptTokenizer::TK_OP_ASSIGN) {
 						constant.type = DataType();
 						constant.type.infer_type = true;
 						tokenizer->advance();
@@ -5153,7 +5153,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 					}
 				}
 
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_OP_ASSIGN) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_OP_ASSIGN) {
 					_set_error("Constants must be assigned immediately.");
 					return;
 				}
@@ -5183,7 +5183,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				}
 
 			} break;
-			case GDScriptTokenizer::TK_PR_ENUM: {
+			case CScriptTokenizer::TK_PR_ENUM: {
 				//multiple constant declarations..
 
 				int last_assign = -1; // Incremented by 1 right before the assignment.
@@ -5218,23 +5218,23 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 					tokenizer->advance();
 				}
-				if (tokenizer->get_token() != GDScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
+				if (tokenizer->get_token() != CScriptTokenizer::TK_CURLY_BRACKET_OPEN) {
 					_set_error("Expected \"{\" in the enum declaration.");
 					return;
 				}
 				tokenizer->advance();
 
 				while (true) {
-					if (tokenizer->get_token() == GDScriptTokenizer::TK_NEWLINE) {
+					if (tokenizer->get_token() == CScriptTokenizer::TK_NEWLINE) {
 						tokenizer->advance(); // Ignore newlines
-					} else if (tokenizer->get_token() == GDScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
+					} else if (tokenizer->get_token() == CScriptTokenizer::TK_CURLY_BRACKET_CLOSE) {
 						tokenizer->advance();
 						break; // End of enum
 					} else if (!tokenizer->is_token_literal(0, true)) {
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_EOF) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_EOF) {
 							_set_error("Unexpected end of file.");
 						} else {
-							_set_error(String("Unexpected ") + GDScriptTokenizer::get_token_name(tokenizer->get_token()) + ", expected an identifier.");
+							_set_error(String("Unexpected ") + CScriptTokenizer::get_token_name(tokenizer->get_token()) + ", expected an identifier.");
 						}
 
 						return;
@@ -5245,7 +5245,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 						ConstantNode *enum_value_expr;
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_OP_ASSIGN) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_OP_ASSIGN) {
 							tokenizer->advance();
 
 							Node *subexpr = _parse_and_reduce_expression(p_class, true, true);
@@ -5277,7 +5277,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 							enum_value_expr->datatype = _type_from_variant(enum_value_expr->value);
 						}
 
-						if (tokenizer->get_token() == GDScriptTokenizer::TK_COMMA) {
+						if (tokenizer->get_token() == CScriptTokenizer::TK_COMMA) {
 							tokenizer->advance();
 						} else if (tokenizer->is_token_literal(0, true)) {
 							_set_error("Unexpected identifier.");
@@ -5337,7 +5337,7 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 
 			} break;
 
-			case GDScriptTokenizer::TK_CONSTANT: {
+			case CScriptTokenizer::TK_CONSTANT: {
 				if (tokenizer->get_token_constant().get_type() == Variant::STRING) {
 					tokenizer->advance();
 					// Ignore
@@ -5347,12 +5347,12 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 				}
 			} break;
 
-			case GDScriptTokenizer::TK_CF_PASS: {
+			case CScriptTokenizer::TK_CF_PASS: {
 				tokenizer->advance();
 			} break;
 
 			default: {
-				if (token == GDScriptTokenizer::TK_IDENTIFIER) {
+				if (token == CScriptTokenizer::TK_IDENTIFIER) {
 					completion_type = COMPLETION_IDENTIFIER;
 					completion_class = current_class;
 					completion_function = current_function;
@@ -5370,14 +5370,14 @@ void GDScriptParser::_parse_class(ClassNode *p_class) {
 	}
 }
 
-void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive) {
+void CScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive) {
 	if (p_class->base_type.has_type) {
 		// Already determined
 	} else if (p_class->extends_used) {
 		//do inheritance
 		String path = p_class->extends_file;
 
-		Ref<GDScript> script;
+		Ref<CScript> script;
 		StringName native;
 		ClassNode *base_class = nullptr;
 
@@ -5426,7 +5426,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 			int extend_iter = 1;
 			String base = p_class->extends_class[0];
 			ClassNode *p = p_class->owner;
-			Ref<GDScript> base_script;
+			Ref<CScript> base_script;
 
 			if (ScriptServer::is_global_class(base)) {
 				base_script = ResourceLoader::load(ScriptServer::get_global_class_path(base));
@@ -5517,7 +5517,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 
 			if (base_script.is_valid()) {
 				String ident = base;
-				Ref<GDScript> find_subclass = base_script;
+				Ref<CScript> find_subclass = base_script;
 
 				for (int i = extend_iter; i < p_class->extends_class.size(); i++) {
 					String subclass = p_class->extends_class[i];
@@ -5527,7 +5527,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 					if (find_subclass->get_subclasses().has(subclass)) {
 						find_subclass = find_subclass->get_subclasses()[subclass];
 					} else if (find_subclass->get_constants().has(subclass)) {
-						Ref<GDScript> new_base_class = find_subclass->get_constants()[subclass];
+						Ref<CScript> new_base_class = find_subclass->get_constants()[subclass];
 						if (new_base_class.is_null()) {
 							_set_error("Constant isn't a class: " + ident, p_class->line);
 							return;
@@ -5547,7 +5547,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 					return;
 				}
 				//if not found, try engine classes
-				if (!GDScriptLanguage::get_singleton()->get_global_map().has(base)) {
+				if (!CScriptLanguage::get_singleton()->get_global_map().has(base)) {
 					_set_error("Unknown class: \"" + base + "\"", p_class->line);
 					return;
 				}
@@ -5562,7 +5562,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 			p_class->base_type.class_type = base_class;
 		} else if (script.is_valid()) {
 			p_class->base_type.has_type = true;
-			p_class->base_type.kind = DataType::GDSCRIPT;
+			p_class->base_type.kind = DataType::CSCRIPT;
 			p_class->base_type.script_type = script;
 			p_class->base_type.native_type = script->get_instance_base_type();
 		} else if (native != StringName()) {
@@ -5589,7 +5589,7 @@ void GDScriptParser::_determine_inheritance(ClassNode *p_class, bool p_recursive
 	}
 }
 
-String GDScriptParser::DataType::to_string() const {
+String CScriptParser::DataType::to_string() const {
 	if (!has_type) {
 		return "var";
 	}
@@ -5602,13 +5602,13 @@ String GDScriptParser::DataType::to_string() const {
 		} break;
 		case NATIVE: {
 			if (is_meta_type) {
-				return "GDScriptNativeClass";
+				return "CScriptNativeClass";
 			}
 			return native_type.operator String();
 		} break;
 
-		case GDSCRIPT: {
-			Ref<GDScript> gds = script_type;
+		case CSCRIPT: {
+			Ref<CScript> gds = script_type;
 			const String &gds_class = gds->get_script_class_name();
 			if (!gds_class.empty()) {
 				return gds_class;
@@ -5632,7 +5632,7 @@ String GDScriptParser::DataType::to_string() const {
 		case CLASS: {
 			ERR_FAIL_COND_V(!class_type, String());
 			if (is_meta_type) {
-				return "GDScript";
+				return "CScript";
 			}
 			if (class_type->name == StringName()) {
 				return "self";
@@ -5646,7 +5646,7 @@ String GDScriptParser::DataType::to_string() const {
 	return "Unresolved";
 }
 
-bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
+bool CScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 	tokenizer->advance();
 	r_type.has_type = true;
 
@@ -5654,7 +5654,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 	bool can_index = false;
 	String full_name;
 
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 		completion_cursor = StringName();
 		completion_type = COMPLETION_TYPE_HINT;
 		completion_class = current_class;
@@ -5668,14 +5668,14 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 	}
 
 	switch (tokenizer->get_token()) {
-		case GDScriptTokenizer::TK_PR_VOID: {
+		case CScriptTokenizer::TK_PR_VOID: {
 			if (!p_can_be_void) {
 				return false;
 			}
 			r_type.kind = DataType::BUILTIN;
 			r_type.builtin_type = Variant::NIL;
 		} break;
-		case GDScriptTokenizer::TK_BUILT_IN_TYPE: {
+		case CScriptTokenizer::TK_BUILT_IN_TYPE: {
 			r_type.builtin_type = tokenizer->get_token_type();
 			if (tokenizer->get_token_type() == Variant::OBJECT) {
 				r_type.kind = DataType::NATIVE;
@@ -5684,7 +5684,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 				r_type.kind = DataType::BUILTIN;
 			}
 		} break;
-		case GDScriptTokenizer::TK_IDENTIFIER: {
+		case CScriptTokenizer::TK_IDENTIFIER: {
 			r_type.native_type = tokenizer->get_token_identifier();
 			if (ClassDB::class_exists(r_type.native_type) || ClassDB::class_exists("_" + r_type.native_type.operator String())) {
 				r_type.kind = DataType::NATIVE;
@@ -5701,7 +5701,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 
 	tokenizer->advance();
 
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_CURSOR) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_CURSOR) {
 		completion_cursor = r_type.native_type;
 		completion_type = COMPLETION_TYPE_HINT;
 		completion_class = current_class;
@@ -5717,7 +5717,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 	if (can_index) {
 		while (!finished) {
 			switch (tokenizer->get_token()) {
-				case GDScriptTokenizer::TK_PERIOD: {
+				case CScriptTokenizer::TK_PERIOD: {
 					if (!can_index) {
 						_set_error("Unexpected \".\".");
 						return false;
@@ -5725,7 +5725,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 					can_index = false;
 					tokenizer->advance();
 				} break;
-				case GDScriptTokenizer::TK_IDENTIFIER: {
+				case CScriptTokenizer::TK_IDENTIFIER: {
 					if (can_index) {
 						_set_error("Unexpected identifier.");
 						return false;
@@ -5749,7 +5749,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 			}
 		}
 
-		if (tokenizer->get_token(-1) == GDScriptTokenizer::TK_PERIOD) {
+		if (tokenizer->get_token(-1) == CScriptTokenizer::TK_PERIOD) {
 			_set_error("Expected a subclass identifier.");
 			return false;
 		}
@@ -5760,7 +5760,7 @@ bool GDScriptParser::_parse_type(DataType &r_type, bool p_can_be_void) {
 	return true;
 }
 
-GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source, int p_line) {
+CScriptParser::DataType CScriptParser::_resolve_type(const DataType &p_source, int p_line) {
 	if (!p_source.has_type) {
 		return p_source;
 	}
@@ -5788,13 +5788,13 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 					result.class_type = static_cast<ClassNode *>(head);
 				} else {
 					Ref<Script> script = ResourceLoader::load(script_path);
-					Ref<GDScript> gds = script;
+					Ref<CScript> gds = script;
 					if (gds.is_valid()) {
 						if (!gds->is_valid()) {
 							_set_error("The class \"" + id + "\" couldn't be fully loaded (script error or cyclic dependency).", p_line);
 							return DataType();
 						}
-						result.kind = DataType::GDSCRIPT;
+						result.kind = DataType::CSCRIPT;
 						result.script_type = gds;
 					} else if (script.is_valid()) {
 						result.kind = DataType::SCRIPT;
@@ -5829,13 +5829,13 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 			}
 			if (!singleton_path.empty()) {
 				Ref<Script> script = ResourceLoader::load(singleton_path);
-				Ref<GDScript> gds = script;
+				Ref<CScript> gds = script;
 				if (gds.is_valid()) {
 					if (!gds->is_valid()) {
 						_set_error("Class '" + id + "' could not be fully loaded (script error or cyclic inheritance).", p_line);
 						return DataType();
 					}
-					result.kind = DataType::GDSCRIPT;
+					result.kind = DataType::CSCRIPT;
 					result.script_type = gds;
 				} else if (script.is_valid()) {
 					result.kind = DataType::SCRIPT;
@@ -5859,9 +5859,9 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 					ERR_FAIL_V(result);
 				}
 				const ConstantNode *cn = static_cast<const ConstantNode *>(p->constant_expressions[id].expression);
-				Ref<GDScript> gds = cn->value;
+				Ref<CScript> gds = cn->value;
 				if (gds.is_valid()) {
-					result.kind = DataType::GDSCRIPT;
+					result.kind = DataType::CSCRIPT;
 					result.script_type = gds;
 					found = true;
 				} else {
@@ -5910,7 +5910,7 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 		}
 
 		// Still look for class constants in parent scripts
-		if (!found && (base_type.kind == DataType::GDSCRIPT || base_type.kind == DataType::SCRIPT)) {
+		if (!found && (base_type.kind == DataType::CSCRIPT || base_type.kind == DataType::SCRIPT)) {
 			Ref<Script> scr = base_type.script_type;
 			ERR_FAIL_COND_V(scr.is_null(), result);
 			while (scr.is_valid()) {
@@ -5918,10 +5918,10 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 				scr->get_constants(&constants);
 
 				if (constants.has(id)) {
-					Ref<GDScript> gds = constants[id];
+					Ref<CScript> gds = constants[id];
 
 					if (gds.is_valid()) {
-						result.kind = DataType::GDSCRIPT;
+						result.kind = DataType::CSCRIPT;
 						result.script_type = gds;
 						found = true;
 					} else {
@@ -5960,7 +5960,7 @@ GDScriptParser::DataType GDScriptParser::_resolve_type(const DataType &p_source,
 	return result;
 }
 
-GDScriptParser::DataType GDScriptParser::_type_from_variant(const Variant &p_value) const {
+CScriptParser::DataType CScriptParser::_type_from_variant(const Variant &p_value) const {
 	DataType result;
 	result.has_type = true;
 	result.is_constant = true;
@@ -5982,9 +5982,9 @@ GDScriptParser::DataType GDScriptParser::_type_from_variant(const Variant &p_val
 		}
 		if (scr.is_valid()) {
 			result.script_type = scr;
-			Ref<GDScript> gds = scr;
+			Ref<CScript> gds = scr;
 			if (gds.is_valid()) {
-				result.kind = DataType::GDSCRIPT;
+				result.kind = DataType::CSCRIPT;
 			} else {
 				result.kind = DataType::SCRIPT;
 			}
@@ -5997,7 +5997,7 @@ GDScriptParser::DataType GDScriptParser::_type_from_variant(const Variant &p_val
 	return result;
 }
 
-GDScriptParser::DataType GDScriptParser::_type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant) const {
+CScriptParser::DataType CScriptParser::_type_from_property(const PropertyInfo &p_property, bool p_nil_is_variant) const {
 	DataType ret;
 	if (p_property.type == Variant::NIL && (p_nil_is_variant || (p_property.usage & PROPERTY_USAGE_NIL_IS_VARIANT))) {
 		// Variant
@@ -6014,7 +6014,7 @@ GDScriptParser::DataType GDScriptParser::_type_from_property(const PropertyInfo
 	return ret;
 }
 
-GDScriptParser::DataType GDScriptParser::_type_from_gdtype(const GDScriptDataType &p_gdtype) const {
+CScriptParser::DataType CScriptParser::_type_from_gdtype(const CScriptDataType &p_gdtype) const {
 	DataType result;
 	if (!p_gdtype.has_type) {
 		return result;
@@ -6026,26 +6026,26 @@ GDScriptParser::DataType GDScriptParser::_type_from_gdtype(const GDScriptDataTyp
 	result.script_type = Ref<Script>(p_gdtype.script_type);
 
 	switch (p_gdtype.kind) {
-		case GDScriptDataType::UNINITIALIZED: {
+		case CScriptDataType::UNINITIALIZED: {
 			ERR_PRINT("Uninitialized datatype. Please report a bug.");
 		} break;
-		case GDScriptDataType::BUILTIN: {
+		case CScriptDataType::BUILTIN: {
 			result.kind = DataType::BUILTIN;
 		} break;
-		case GDScriptDataType::NATIVE: {
+		case CScriptDataType::NATIVE: {
 			result.kind = DataType::NATIVE;
 		} break;
-		case GDScriptDataType::GDSCRIPT: {
-			result.kind = DataType::GDSCRIPT;
+		case CScriptDataType::CSCRIPT: {
+			result.kind = DataType::CSCRIPT;
 		} break;
-		case GDScriptDataType::SCRIPT: {
+		case CScriptDataType::SCRIPT: {
 			result.kind = DataType::SCRIPT;
 		} break;
 	}
 	return result;
 }
 
-GDScriptParser::DataType GDScriptParser::_get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const {
+CScriptParser::DataType CScriptParser::_get_operation_type(const Variant::Operator p_op, const DataType &p_a, const DataType &p_b, bool &r_valid) const {
 	if (!p_a.has_type || !p_b.has_type) {
 		r_valid = true;
 		return DataType();
@@ -6102,7 +6102,7 @@ GDScriptParser::DataType GDScriptParser::_get_operation_type(const Variant::Oper
 	return DataType();
 }
 
-Variant::Operator GDScriptParser::_get_variant_operation(const OperatorNode::Operator &p_op) const {
+Variant::Operator CScriptParser::_get_variant_operation(const OperatorNode::Operator &p_op) const {
 	switch (p_op) {
 		case OperatorNode::OP_NEG: {
 			return Variant::OP_NEGATE;
@@ -6189,7 +6189,7 @@ Variant::Operator GDScriptParser::_get_variant_operation(const OperatorNode::Ope
 	}
 }
 
-bool GDScriptParser::_is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion) const {
+bool CScriptParser::_is_type_compatible(const DataType &p_container, const DataType &p_expression, bool p_allow_implicit_conversion) const {
 	// Ignore for completion
 	if (!check_types || for_completion) {
 		return true;
@@ -6244,13 +6244,13 @@ bool GDScriptParser::_is_type_compatible(const DataType &p_container, const Data
 				return false;
 			}
 			if (p_expression.is_meta_type) {
-				expr_native = GDScriptNativeClass::get_class_static();
+				expr_native = CScriptNativeClass::get_class_static();
 			} else {
 				expr_native = p_expression.native_type;
 			}
 		} break;
 		case DataType::SCRIPT:
-		case DataType::GDSCRIPT: {
+		case DataType::CSCRIPT: {
 			if (p_container.kind == DataType::CLASS) {
 				// This cannot be resolved without cyclic dependencies, so just bail out
 				return false;
@@ -6264,7 +6264,7 @@ bool GDScriptParser::_is_type_compatible(const DataType &p_container, const Data
 		} break;
 		case DataType::CLASS: {
 			if (p_expression.is_meta_type) {
-				expr_native = GDScript::get_class_static();
+				expr_native = CScript::get_class_static();
 			} else {
 				expr_class = p_expression.class_type;
 				ClassNode *base = expr_class;
@@ -6288,16 +6288,16 @@ bool GDScriptParser::_is_type_compatible(const DataType &p_container, const Data
 	switch (p_container.kind) {
 		case DataType::NATIVE: {
 			if (p_container.is_meta_type) {
-				return ClassDB::is_parent_class(expr_native, GDScriptNativeClass::get_class_static());
+				return ClassDB::is_parent_class(expr_native, CScriptNativeClass::get_class_static());
 			} else {
 				StringName container_native = ClassDB::class_exists(p_container.native_type) ? p_container.native_type : StringName("_" + p_container.native_type);
 				return ClassDB::is_parent_class(expr_native, container_native);
 			}
 		} break;
 		case DataType::SCRIPT:
-		case DataType::GDSCRIPT: {
+		case DataType::CSCRIPT: {
 			if (p_container.is_meta_type) {
-				return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
+				return ClassDB::is_parent_class(expr_native, CScript::get_class_static());
 			}
 			if (expr_class == head && p_container.script_type->get_path() == self_path) {
 				// Special case: container is self script and expression is self
@@ -6313,7 +6313,7 @@ bool GDScriptParser::_is_type_compatible(const DataType &p_container, const Data
 		} break;
 		case DataType::CLASS: {
 			if (p_container.is_meta_type) {
-				return ClassDB::is_parent_class(expr_native, GDScript::get_class_static());
+				return ClassDB::is_parent_class(expr_native, CScript::get_class_static());
 			}
 			if (p_container.class_type == head && expr_script.is_valid() && expr_script->get_path() == self_path) {
 				// Special case: container is self and expression is self script
@@ -6335,7 +6335,7 @@ bool GDScriptParser::_is_type_compatible(const DataType &p_container, const Data
 	return false;
 }
 
-GDScriptParser::Node *GDScriptParser::_get_default_value_for_type(const DataType &p_type, int p_line) {
+CScriptParser::Node *CScriptParser::_get_default_value_for_type(const DataType &p_type, int p_line) {
 	Node *result;
 
 	if (p_type.has_type && p_type.kind == DataType::BUILTIN && p_type.builtin_type != Variant::NIL && p_type.builtin_type != Variant::OBJECT) {
@@ -6360,7 +6360,7 @@ GDScriptParser::Node *GDScriptParser::_get_default_value_for_type(const DataType
 	return result;
 }
 
-GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
+CScriptParser::DataType CScriptParser::_reduce_node_type(Node *p_node) {
 #ifdef DEBUG_ENABLED
 	if (p_node->get_datatype().has_type && p_node->type != Node::TYPE_ARRAY && p_node->type != Node::TYPE_DICTIONARY) {
 #else
@@ -6452,7 +6452,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 				}
 			} else {
 #ifdef DEBUG_ENABLED
-				_add_warning(GDScriptWarning::UNSAFE_CAST, cn->line, cn->cast_type.to_string());
+				_add_warning(CScriptWarning::UNSAFE_CAST, cn->line, cn->cast_type.to_string());
 #endif // DEBUG_ENABLED
 				_mark_line_as_unsafe(cn->line);
 			}
@@ -6584,7 +6584,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 #ifdef DEBUG_ENABLED
 					if (var_op == Variant::OP_DIVIDE && argument_a_type.kind == DataType::BUILTIN && argument_a_type.builtin_type == Variant::INT &&
 							argument_b_type.kind == DataType::BUILTIN && argument_b_type.builtin_type == Variant::INT) {
-						_add_warning(GDScriptWarning::INTEGER_DIVISION, op->line);
+						_add_warning(CScriptWarning::INTEGER_DIVISION, op->line);
 					}
 #endif // DEBUG_ENABLED
 
@@ -6609,7 +6609,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 						node_type = false_type;
 					} else {
 #ifdef DEBUG_ENABLED
-						_add_warning(GDScriptWarning::INCOMPATIBLE_TERNARY, op->line);
+						_add_warning(CScriptWarning::INCOMPATIBLE_TERNARY, op->line);
 #endif // DEBUG_ENABLED
 					}
 				} break;
@@ -6676,7 +6676,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 #ifdef DEBUG_ENABLED
 							if (!node_type.has_type) {
 								_mark_line_as_unsafe(op->line);
-								_add_warning(GDScriptWarning::UNSAFE_PROPERTY_ACCESS, op->line, member_id->name.operator String(), base_type.to_string());
+								_add_warning(CScriptWarning::UNSAFE_PROPERTY_ACCESS, op->line, member_id->name.operator String(), base_type.to_string());
 							}
 #endif // DEBUG_ENABLED
 						}
@@ -6766,7 +6766,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 								return DataType();
 							}
 
-							if (op->arguments[1]->type == GDScriptParser::Node::TYPE_CONSTANT) {
+							if (op->arguments[1]->type == CScriptParser::Node::TYPE_CONSTANT) {
 								ConstantNode *cn = static_cast<ConstantNode *>(op->arguments[1]);
 								// Index is a constant, just try it if possible
 								switch (base_type.builtin_type) {
@@ -6884,7 +6884,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_node_type(Node *p_node) {
 	return node_type;
 }
 
-bool GDScriptParser::_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 CScriptParser::_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 {
 	r_static = false;
 	r_default_arg_count = 0;
 
@@ -6933,13 +6933,13 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 	}
 
 	// Nothing in current file, check parent script
-	Ref<GDScript> base_gdscript;
+	Ref<CScript> base_gdscript;
 	Ref<Script> base_script;
 	StringName native;
-	if (p_base_type.kind == DataType::GDSCRIPT) {
+	if (p_base_type.kind == DataType::CSCRIPT) {
 		base_gdscript = p_base_type.script_type;
 		if (base_gdscript.is_null() || !base_gdscript->is_valid()) {
-			// GDScript wasn't properly compíled, don't bother trying
+			// CScript wasn't properly compíled, don't bother trying
 			return false;
 		}
 	} else if (p_base_type.kind == DataType::SCRIPT) {
@@ -6951,10 +6951,10 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 	while (base_gdscript.is_valid()) {
 		native = base_gdscript->get_instance_base_type();
 
-		Map<StringName, GDScriptFunction *> funcs = base_gdscript->get_member_functions();
+		Map<StringName, CScriptFunction *> funcs = base_gdscript->get_member_functions();
 
 		if (funcs.has(p_function)) {
-			GDScriptFunction *f = funcs[p_function];
+			CScriptFunction *f = funcs[p_function];
 			r_static = f->is_static();
 			r_default_arg_count = f->get_default_argument_count();
 			r_return_type = _type_from_gdtype(f->get_return_type());
@@ -7022,7 +7022,7 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 		}
 
 		// If the base is a script, it might be trying to access members of the Script class itself
-		if (original_type.is_meta_type && !(p_function == "new") && (original_type.kind == DataType::SCRIPT || original_type.kind == DataType::GDSCRIPT)) {
+		if (original_type.is_meta_type && !(p_function == "new") && (original_type.kind == DataType::SCRIPT || original_type.kind == DataType::CSCRIPT)) {
 			method = ClassDB::get_method(original_type.script_type->get_class_name(), p_function);
 
 			if (method) {
@@ -7068,7 +7068,7 @@ bool GDScriptParser::_get_function_signature(DataType &p_base_type, const String
 #endif
 }
 
-GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const OperatorNode *p_call) {
+CScriptParser::DataType CScriptParser::_reduce_function_call_type(const OperatorNode *p_call) {
 	if (p_call->arguments.size() < 1) {
 		_set_error("Parser bug: function call without enough arguments.", p_call->line);
 		ERR_FAIL_V(DataType());
@@ -7084,7 +7084,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 #endif
 
 	switch (p_call->arguments[0]->type) {
-		case GDScriptParser::Node::TYPE_TYPE: {
+		case CScriptParser::Node::TYPE_TYPE: {
 			// Built-in constructor, special case
 			TypeNode *tn = static_cast<TypeNode *>(p_call->arguments[0]);
 
@@ -7140,10 +7140,10 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 					} else {
 #ifdef DEBUG_ENABLED
 						if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_types[i].kind == DataType::BUILTIN && par_types[i].builtin_type == Variant::REAL) {
-							_add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, Variant::get_type_name(tn->vtype));
+							_add_warning(CScriptWarning::NARROWING_CONVERSION, p_call->line, Variant::get_type_name(tn->vtype));
 						}
 						if (par_types[i].may_yield && p_call->arguments[i + 1]->type == Node::TYPE_OPERATOR) {
-							_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i + 1])));
+							_add_warning(CScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i + 1])));
 						}
 #endif // DEBUG_ENABLED
 					}
@@ -7175,9 +7175,9 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 			}
 			return DataType();
 		} break;
-		case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
+		case CScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
 			BuiltInFunctionNode *func = static_cast<BuiltInFunctionNode *>(p_call->arguments[0]);
-			MethodInfo mi = GDScriptFunctions::get_info(func->function);
+			MethodInfo mi = CScriptFunctions::get_info(func->function);
 
 			return_type = _type_from_property(mi.return_val, false);
 
@@ -7319,12 +7319,12 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 				valid = _get_member_type(original_type, func_id->name, tmp_type);
 				if (valid) {
 					if (tmp_type.is_constant) {
-						_add_warning(GDScriptWarning::CONSTANT_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
+						_add_warning(CScriptWarning::CONSTANT_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
 					} else {
-						_add_warning(GDScriptWarning::PROPERTY_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
+						_add_warning(CScriptWarning::PROPERTY_USED_AS_FUNCTION, p_call->line, callee_name, original_type.to_string());
 					}
 				}
-				_add_warning(GDScriptWarning::UNSAFE_METHOD_ACCESS, p_call->line, callee_name, original_type.to_string());
+				_add_warning(CScriptWarning::UNSAFE_METHOD_ACCESS, p_call->line, callee_name, original_type.to_string());
 				_mark_line_as_unsafe(p_call->line);
 #endif // DEBUG_ENABLED
 				return DataType();
@@ -7383,7 +7383,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 		if (!par_type.has_type) {
 			_mark_line_as_unsafe(p_call->line);
 			if (par_type.may_yield && p_call->arguments[i]->type == Node::TYPE_OPERATOR) {
-				_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i])));
+				_add_warning(CScriptWarning::FUNCTION_MAY_YIELD, p_call->line, _find_function_name(static_cast<OperatorNode *>(p_call->arguments[i])));
 			}
 		} else if (!_is_type_compatible(arg_types[i - arg_diff], par_type, true)) {
 			// Supertypes are acceptable for dynamic compliance
@@ -7398,7 +7398,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 			}
 		} else {
 			if (arg_type.kind == DataType::BUILTIN && arg_type.builtin_type == Variant::INT && par_type.kind == DataType::BUILTIN && par_type.builtin_type == Variant::REAL) {
-				_add_warning(GDScriptWarning::NARROWING_CONVERSION, p_call->line, callee_name);
+				_add_warning(CScriptWarning::NARROWING_CONVERSION, p_call->line, callee_name);
 			}
 		}
 	}
@@ -7407,7 +7407,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_function_call_type(const Operat
 	return return_type;
 }
 
-bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type, bool *r_is_const) const {
+bool CScriptParser::_get_member_type(const DataType &p_base_type, const StringName &p_member, DataType &r_member_type, bool *r_is_const) const {
 	DataType base_type = p_base_type;
 
 	// Check classes in current file
@@ -7457,11 +7457,11 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 		}
 	}
 
-	Ref<GDScript> gds;
-	if (base_type.kind == DataType::GDSCRIPT) {
+	Ref<CScript> gds;
+	if (base_type.kind == DataType::CSCRIPT) {
 		gds = base_type.script_type;
 		if (gds.is_null() || !gds->is_valid()) {
-			// GDScript wasn't properly compíled, don't bother trying
+			// CScript wasn't properly compíled, don't bother trying
 			return false;
 		}
 	}
@@ -7476,7 +7476,7 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 		native = base_type.native_type;
 	}
 
-	// Check GDScripts
+	// Check CScripts
 	while (gds.is_valid()) {
 		if (gds->get_constants().has(p_member)) {
 			Variant c = gds->get_constants()[p_member];
@@ -7585,7 +7585,7 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 	}
 
 	// If the base is a script, it might be trying to access members of the Script class itself
-	if (p_base_type.is_meta_type && (p_base_type.kind == DataType::SCRIPT || p_base_type.kind == DataType::GDSCRIPT)) {
+	if (p_base_type.is_meta_type && (p_base_type.kind == DataType::SCRIPT || p_base_type.kind == DataType::CSCRIPT)) {
 		native = p_base_type.script_type->get_class_name();
 		ClassDB::get_integer_constant(native, p_member, &valid);
 		if (valid) {
@@ -7628,7 +7628,7 @@ bool GDScriptParser::_get_member_type(const DataType &p_base_type, const StringN
 	return false;
 }
 
-GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType *p_base_type, const StringName &p_identifier, int p_line, bool p_is_indexing) {
+CScriptParser::DataType CScriptParser::_reduce_identifier_type(const DataType *p_base_type, const StringName &p_identifier, int p_line, bool p_is_indexing) {
 	if (p_base_type && !p_base_type->has_type) {
 		return DataType();
 	}
@@ -7714,13 +7714,13 @@ GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType
 				result.script_type = scr;
 				result.is_constant = true;
 				result.is_meta_type = true;
-				Ref<GDScript> gds = scr;
+				Ref<CScript> gds = scr;
 				if (gds.is_valid()) {
 					if (!gds->is_valid()) {
 						_set_error("The class \"" + p_identifier + "\" couldn't be fully loaded (script error or cyclic dependency).");
 						return DataType();
 					}
-					result.kind = DataType::GDSCRIPT;
+					result.kind = DataType::CSCRIPT;
 				} else {
 					result.kind = DataType::SCRIPT;
 				}
@@ -7730,14 +7730,14 @@ GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType
 			return DataType();
 		}
 
-		if (GDScriptLanguage::get_singleton()->get_global_map().has(p_identifier)) {
-			int idx = GDScriptLanguage::get_singleton()->get_global_map()[p_identifier];
-			Variant g = GDScriptLanguage::get_singleton()->get_global_array()[idx];
+		if (CScriptLanguage::get_singleton()->get_global_map().has(p_identifier)) {
+			int idx = CScriptLanguage::get_singleton()->get_global_map()[p_identifier];
+			Variant g = CScriptLanguage::get_singleton()->get_global_array()[idx];
 			return _type_from_variant(g);
 		}
 
-		if (GDScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
-			Variant g = GDScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier];
+		if (CScriptLanguage::get_singleton()->get_named_globals_map().has(p_identifier)) {
+			Variant g = CScriptLanguage::get_singleton()->get_named_globals_map()[p_identifier];
 			return _type_from_variant(g);
 		}
 
@@ -7766,13 +7766,13 @@ GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType
 					result.is_constant = true;
 					result.script_type = singleton;
 
-					Ref<GDScript> gds = singleton;
+					Ref<CScript> gds = singleton;
 					if (gds.is_valid()) {
 						if (!gds->is_valid()) {
 							_set_error("Couldn't fully load the singleton script \"" + p_identifier + "\" (possible cyclic reference or parse error).", p_line);
 							return DataType();
 						}
-						result.kind = DataType::GDSCRIPT;
+						result.kind = DataType::CSCRIPT;
 					} else {
 						result.kind = DataType::SCRIPT;
 					}
@@ -7792,7 +7792,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType
 		bool _static;
 		bool vararg;
 		if (_get_function_signature(base_type, p_identifier, tmp_type, arg_types, argcount, _static, vararg)) {
-			_add_warning(GDScriptWarning::FUNCTION_USED_AS_PROPERTY, p_line, p_identifier.operator String(), base_type.to_string());
+			_add_warning(CScriptWarning::FUNCTION_USED_AS_PROPERTY, p_line, p_identifier.operator String(), base_type.to_string());
 		}
 	}
 #endif // DEBUG_ENABLED
@@ -7801,7 +7801,7 @@ GDScriptParser::DataType GDScriptParser::_reduce_identifier_type(const DataType
 	return DataType();
 }
 
-void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
+void CScriptParser::_check_class_level_types(ClassNode *p_class) {
 	// Names of internal object properties that we check to avoid overriding them.
 	// "__meta__" could also be in here, but since it doesn't really affect object metadata,
 	// it is okay to override it on script.
@@ -7882,7 +7882,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 					// Replace assignment with implicit conversion
 					BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
 					convert->line = v.line;
-					convert->function = GDScriptFunctions::TYPE_CONVERT;
+					convert->function = CScriptFunctions::TYPE_CONVERT;
 
 					ConstantNode *tgt_type = alloc_node<ConstantNode>();
 					tgt_type->line = v.line;
@@ -8022,7 +8022,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 	}
 
 	StringName native;
-	if (base.kind == DataType::GDSCRIPT || base.kind == DataType::SCRIPT) {
+	if (base.kind == DataType::CSCRIPT || base.kind == DataType::SCRIPT) {
 		Ref<Script> scr = base.script_type;
 		if (scr.is_valid() && scr->is_valid()) {
 			native = scr->get_instance_base_type();
@@ -8057,7 +8057,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 	}
 }
 
-void GDScriptParser::_check_function_types(FunctionNode *p_function) {
+void CScriptParser::_check_function_types(FunctionNode *p_function) {
 	p_function->return_type = _resolve_type(p_function->return_type, p_function->line);
 
 	// Arguments
@@ -8096,11 +8096,11 @@ void GDScriptParser::_check_function_types(FunctionNode *p_function) {
 		}
 #ifdef DEBUG_ENABLED
 		if (p_function->arguments_usage[i] == 0 && !p_function->arguments[i].operator String().begins_with("_")) {
-			_add_warning(GDScriptWarning::UNUSED_ARGUMENT, p_function->line, p_function->name, p_function->arguments[i].operator String());
+			_add_warning(CScriptWarning::UNUSED_ARGUMENT, p_function->line, p_function->name, p_function->arguments[i].operator String());
 		}
 		for (int j = 0; j < current_class->variables.size(); j++) {
 			if (current_class->variables[j].identifier == p_function->arguments[i]) {
-				_add_warning(GDScriptWarning::SHADOWED_VARIABLE, p_function->line, p_function->arguments[i], itos(current_class->variables[j].line));
+				_add_warning(CScriptWarning::SHADOWED_VARIABLE, p_function->line, p_function->arguments[i], itos(current_class->variables[j].line));
 			}
 		}
 #endif // DEBUG_ENABLED
@@ -8172,13 +8172,13 @@ void GDScriptParser::_check_function_types(FunctionNode *p_function) {
 	}
 
 	if (p_function->has_yield) {
-		// yield() will make the function return a GDScriptFunctionState, so the type is ambiguous
+		// yield() will make the function return a CScriptFunctionState, so the type is ambiguous
 		p_function->return_type.has_type = false;
 		p_function->return_type.may_yield = true;
 	}
 }
 
-void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
+void CScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 	// Function blocks
 	for (int i = 0; i < p_class->static_functions.size(); i++) {
 		current_function = p_class->static_functions[i];
@@ -8208,12 +8208,12 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 	// Warnings
 	for (int i = 0; i < p_class->variables.size(); i++) {
 		if (p_class->variables[i].usages == 0) {
-			_add_warning(GDScriptWarning::UNUSED_CLASS_VARIABLE, p_class->variables[i].line, p_class->variables[i].identifier);
+			_add_warning(CScriptWarning::UNUSED_CLASS_VARIABLE, p_class->variables[i].line, p_class->variables[i].identifier);
 		}
 	}
 	for (int i = 0; i < p_class->_signals.size(); i++) {
 		if (p_class->_signals[i].emissions == 0) {
-			_add_warning(GDScriptWarning::UNUSED_SIGNAL, p_class->_signals[i].line, p_class->_signals[i].name);
+			_add_warning(CScriptWarning::UNUSED_SIGNAL, p_class->_signals[i].line, p_class->_signals[i].name);
 		}
 	}
 #endif // DEBUG_ENABLED
@@ -8230,18 +8230,18 @@ void GDScriptParser::_check_class_blocks_types(ClassNode *p_class) {
 }
 
 #ifdef DEBUG_ENABLED
-static String _find_function_name(const GDScriptParser::OperatorNode *p_call) {
+static String _find_function_name(const CScriptParser::OperatorNode *p_call) {
 	switch (p_call->arguments[0]->type) {
-		case GDScriptParser::Node::TYPE_TYPE: {
-			return Variant::get_type_name(static_cast<GDScriptParser::TypeNode *>(p_call->arguments[0])->vtype);
+		case CScriptParser::Node::TYPE_TYPE: {
+			return Variant::get_type_name(static_cast<CScriptParser::TypeNode *>(p_call->arguments[0])->vtype);
 		} break;
-		case GDScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
-			return GDScriptFunctions::get_func_name(static_cast<GDScriptParser::BuiltInFunctionNode *>(p_call->arguments[0])->function);
+		case CScriptParser::Node::TYPE_BUILT_IN_FUNCTION: {
+			return CScriptFunctions::get_func_name(static_cast<CScriptParser::BuiltInFunctionNode *>(p_call->arguments[0])->function);
 		} break;
 		default: {
-			int id_index = p_call->op == GDScriptParser::OperatorNode::OP_PARENT_CALL ? 0 : 1;
-			if (p_call->arguments.size() > id_index && p_call->arguments[id_index]->type == GDScriptParser::Node::TYPE_IDENTIFIER) {
-				return static_cast<GDScriptParser::IdentifierNode *>(p_call->arguments[id_index])->name;
+			int id_index = p_call->op == CScriptParser::OperatorNode::OP_PARENT_CALL ? 0 : 1;
+			if (p_call->arguments.size() > id_index && p_call->arguments[id_index]->type == CScriptParser::Node::TYPE_IDENTIFIER) {
+				return static_cast<CScriptParser::IdentifierNode *>(p_call->arguments[id_index])->name;
 			}
 		} break;
 	}
@@ -8249,7 +8249,7 @@ static String _find_function_name(const GDScriptParser::OperatorNode *p_call) {
 }
 #endif // DEBUG_ENABLED
 
-void GDScriptParser::_check_block_types(BlockNode *p_block) {
+void CScriptParser::_check_block_types(BlockNode *p_block) {
 	Node *last_var_assign = nullptr;
 
 	// Check each statement
@@ -8280,16 +8280,16 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 						if (lv->assign->type == Node::TYPE_OPERATOR) {
 							OperatorNode *call = static_cast<OperatorNode *>(lv->assign);
 							if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
-								_add_warning(GDScriptWarning::VOID_ASSIGNMENT, lv->line, _find_function_name(call));
+								_add_warning(CScriptWarning::VOID_ASSIGNMENT, lv->line, _find_function_name(call));
 							}
 						}
 					}
 					if (lv->datatype.has_type && assign_type.may_yield && lv->assign->type == Node::TYPE_OPERATOR) {
-						_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, lv->line, _find_function_name(static_cast<OperatorNode *>(lv->assign)));
+						_add_warning(CScriptWarning::FUNCTION_MAY_YIELD, lv->line, _find_function_name(static_cast<OperatorNode *>(lv->assign)));
 					}
 					for (int i = 0; i < current_class->variables.size(); i++) {
 						if (current_class->variables[i].identifier == lv->name) {
-							_add_warning(GDScriptWarning::SHADOWED_VARIABLE, lv->line, lv->name, itos(current_class->variables[i].line));
+							_add_warning(CScriptWarning::SHADOWED_VARIABLE, lv->line, lv->name, itos(current_class->variables[i].line));
 						}
 					}
 #endif // DEBUG_ENABLED
@@ -8309,7 +8309,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							// Replace assignment with implicit conversion
 							BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
 							convert->line = lv->line;
-							convert->function = GDScriptFunctions::TYPE_CONVERT;
+							convert->function = CScriptFunctions::TYPE_CONVERT;
 
 							ConstantNode *tgt_type = alloc_node<ConstantNode>();
 							tgt_type->line = lv->line;
@@ -8326,7 +8326,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							lv->assign_op->arguments.write[1] = convert_call;
 #ifdef DEBUG_ENABLED
 							if (lv->datatype.builtin_type == Variant::INT && assign_type.builtin_type == Variant::REAL) {
-								_add_warning(GDScriptWarning::NARROWING_CONVERSION, lv->line);
+								_add_warning(CScriptWarning::NARROWING_CONVERSION, lv->line);
 							}
 #endif // DEBUG_ENABLED
 						}
@@ -8420,12 +8420,12 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							if (op->arguments[1]->type == Node::TYPE_OPERATOR) {
 								OperatorNode *call = static_cast<OperatorNode *>(op->arguments[1]);
 								if (call->op == OperatorNode::OP_CALL || call->op == OperatorNode::OP_PARENT_CALL) {
-									_add_warning(GDScriptWarning::VOID_ASSIGNMENT, op->line, _find_function_name(call));
+									_add_warning(CScriptWarning::VOID_ASSIGNMENT, op->line, _find_function_name(call));
 								}
 							}
 						}
 						if (lh_type.has_type && rh_type.may_yield && op->arguments[1]->type == Node::TYPE_OPERATOR) {
-							_add_warning(GDScriptWarning::FUNCTION_MAY_YIELD, op->line, _find_function_name(static_cast<OperatorNode *>(op->arguments[1])));
+							_add_warning(CScriptWarning::FUNCTION_MAY_YIELD, op->line, _find_function_name(static_cast<OperatorNode *>(op->arguments[1])));
 						}
 
 #endif // DEBUG_ENABLED
@@ -8448,7 +8448,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 									// Replace assignment with implicit conversion
 									BuiltInFunctionNode *convert = alloc_node<BuiltInFunctionNode>();
 									convert->line = op->line;
-									convert->function = GDScriptFunctions::TYPE_CONVERT;
+									convert->function = CScriptFunctions::TYPE_CONVERT;
 
 									ConstantNode *tgt_type = alloc_node<ConstantNode>();
 									tgt_type->line = op->line;
@@ -8467,7 +8467,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 								}
 #ifdef DEBUG_ENABLED
 								if (lh_type.builtin_type == Variant::INT && rh_type.builtin_type == Variant::REAL) {
-									_add_warning(GDScriptWarning::NARROWING_CONVERSION, op->line);
+									_add_warning(CScriptWarning::NARROWING_CONVERSION, op->line);
 								}
 #endif // DEBUG_ENABLED
 							}
@@ -8490,7 +8490,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 							if (func_name.empty()) {
 								func_name = "<undetected name>";
 							}
-							_add_warning(GDScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
+							_add_warning(CScriptWarning::RETURN_VALUE_DISCARDED, op->line, func_name);
 						}
 #endif // DEBUG_ENABLED
 						if (error_set) {
@@ -8506,9 +8506,9 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 						_reduce_node_type(op); // Test for safety anyway
 #ifdef DEBUG_ENABLED
 						if (op->op == OperatorNode::OP_TERNARY_IF) {
-							_add_warning(GDScriptWarning::STANDALONE_TERNARY, statement->line);
+							_add_warning(CScriptWarning::STANDALONE_TERNARY, statement->line);
 						} else {
-							_add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
+							_add_warning(CScriptWarning::STANDALONE_EXPRESSION, statement->line);
 						}
 #endif // DEBUG_ENABLED
 					}
@@ -8581,7 +8581,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 				_mark_line_as_safe(statement->line);
 				_reduce_node_type(statement); // Test for safety anyway
 #ifdef DEBUG_ENABLED
-				_add_warning(GDScriptWarning::STANDALONE_EXPRESSION, statement->line);
+				_add_warning(CScriptWarning::STANDALONE_EXPRESSION, statement->line);
 #endif // DEBUG_ENABLED
 			}
 		}
@@ -8603,16 +8603,16 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 		LocalVarNode *lv = E->get();
 		if (!lv->name.operator String().begins_with("_")) {
 			if (lv->usages == 0) {
-				_add_warning(GDScriptWarning::UNUSED_VARIABLE, lv->line, lv->name);
+				_add_warning(CScriptWarning::UNUSED_VARIABLE, lv->line, lv->name);
 			} else if (lv->assignments == 0) {
-				_add_warning(GDScriptWarning::UNASSIGNED_VARIABLE, lv->line, lv->name);
+				_add_warning(CScriptWarning::UNASSIGNED_VARIABLE, lv->line, lv->name);
 			}
 		}
 	}
 #endif // DEBUG_ENABLED
 }
 
-void GDScriptParser::_set_error(const String &p_error, int p_line, int p_column) {
+void CScriptParser::_set_error(const String &p_error, int p_line, int p_column) {
 	if (error_set) {
 		return; //allow no further errors
 	}
@@ -8624,7 +8624,7 @@ void GDScriptParser::_set_error(const String &p_error, int p_line, int p_column)
 }
 
 #ifdef DEBUG_ENABLED
-void GDScriptParser::_add_warning(int p_code, int p_line, const String &p_symbol1, const String &p_symbol2, const String &p_symbol3, const String &p_symbol4) {
+void CScriptParser::_add_warning(int p_code, int p_line, const String &p_symbol1, const String &p_symbol2, const String &p_symbol3, const String &p_symbol4) {
 	Vector<String> symbols;
 	if (!p_symbol1.empty()) {
 		symbols.push_back(p_symbol1);
@@ -8641,14 +8641,14 @@ void GDScriptParser::_add_warning(int p_code, int p_line, const String &p_symbol
 	_add_warning(p_code, p_line, symbols);
 }
 
-void GDScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &p_symbols) {
+void CScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &p_symbols) {
 	if (GLOBAL_GET("debug/gdscript/warnings/exclude_addons").booleanize() && base_path.begins_with("res://addons/")) {
 		return;
 	}
 	if (tokenizer->is_ignoring_warnings() || !GLOBAL_GET("debug/gdscript/warnings/enable").booleanize()) {
 		return;
 	}
-	String warn_name = GDScriptWarning::get_name_from_code((GDScriptWarning::Code)p_code).to_lower();
+	String warn_name = CScriptWarning::get_name_from_code((CScriptWarning::Code)p_code).to_lower();
 	if (tokenizer->get_warning_global_skips().has(warn_name)) {
 		return;
 	}
@@ -8656,13 +8656,13 @@ void GDScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &
 		return;
 	}
 
-	GDScriptWarning warn;
-	warn.code = (GDScriptWarning::Code)p_code;
+	CScriptWarning warn;
+	warn.code = (CScriptWarning::Code)p_code;
 	warn.symbols = p_symbols;
 	warn.line = p_line == -1 ? tokenizer->get_token_line() : p_line;
 
-	List<GDScriptWarning>::Element *before = nullptr;
-	for (List<GDScriptWarning>::Element *E = warnings.front(); E; E = E->next()) {
+	List<CScriptWarning>::Element *before = nullptr;
+	for (List<CScriptWarning>::Element *E = warnings.front(); E; E = E->next()) {
 		if (E->get().line > warn.line) {
 			break;
 		}
@@ -8676,22 +8676,22 @@ void GDScriptParser::_add_warning(int p_code, int p_line, const Vector<String> &
 }
 #endif // DEBUG_ENABLED
 
-String GDScriptParser::get_error() const {
+String CScriptParser::get_error() const {
 	return error;
 }
 
-int GDScriptParser::get_error_line() const {
+int CScriptParser::get_error_line() const {
 	return error_line;
 }
-int GDScriptParser::get_error_column() const {
+int CScriptParser::get_error_column() const {
 	return error_column;
 }
 
-bool GDScriptParser::has_error() const {
+bool CScriptParser::has_error() const {
 	return error_set;
 }
 
-Error GDScriptParser::_parse(const String &p_base_path) {
+Error CScriptParser::_parse(const String &p_base_path) {
 	base_path = p_base_path;
 
 	//assume class
@@ -8704,7 +8704,7 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 
 	_parse_class(main_class);
 
-	if (tokenizer->get_token() == GDScriptTokenizer::TK_ERROR) {
+	if (tokenizer->get_token() == CScriptTokenizer::TK_ERROR) {
 		error_set = false;
 		_set_error("Parse error: " + tokenizer->get_token_error());
 	}
@@ -8760,8 +8760,8 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 	// Resolve warning ignores
 	Vector<Pair<int, String>> warning_skips = tokenizer->get_warning_skips();
 	bool warning_is_error = GLOBAL_GET("debug/gdscript/warnings/treat_warnings_as_errors").booleanize();
-	for (List<GDScriptWarning>::Element *E = warnings.front(); E;) {
-		GDScriptWarning &w = E->get();
+	for (List<CScriptWarning>::Element *E = warnings.front(); E;) {
+		CScriptWarning &w = E->get();
 		int skip_index = -1;
 		for (int i = 0; i < warning_skips.size(); i++) {
 			if (warning_skips[i].first > w.line) {
@@ -8769,10 +8769,10 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 			}
 			skip_index = i;
 		}
-		List<GDScriptWarning>::Element *next = E->next();
+		List<CScriptWarning>::Element *next = E->next();
 		bool erase = false;
 		if (skip_index != -1) {
-			if (warning_skips[skip_index].second == GDScriptWarning::get_name_from_code(w.code).to_lower()) {
+			if (warning_skips[skip_index].second == CScriptWarning::get_name_from_code(w.code).to_lower()) {
 				erase = true;
 			}
 			warning_skips.remove(skip_index);
@@ -8790,11 +8790,11 @@ Error GDScriptParser::_parse(const String &p_base_path) {
 	return OK;
 }
 
-Error GDScriptParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path, const String &p_self_path) {
+Error CScriptParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_base_path, const String &p_self_path) {
 	clear();
 
 	self_path = p_self_path;
-	GDScriptTokenizerBuffer *tb = memnew(GDScriptTokenizerBuffer);
+	CScriptTokenizerBuffer *tb = memnew(CScriptTokenizerBuffer);
 	tb->set_code_buffer(p_bytecode);
 	tokenizer = tb;
 	Error ret = _parse(p_base_path);
@@ -8803,11 +8803,11 @@ Error GDScriptParser::parse_bytecode(const Vector<uint8_t> &p_bytecode, const St
 	return ret;
 }
 
-Error GDScriptParser::parse(const String &p_code, const String &p_base_path, bool p_just_validate, const String &p_self_path, bool p_for_completion, Set<int> *r_safe_lines, bool p_dependencies_only) {
+Error CScriptParser::parse(const String &p_code, const String &p_base_path, bool p_just_validate, const String &p_self_path, bool p_for_completion, Set<int> *r_safe_lines, bool p_dependencies_only) {
 	clear();
 
 	self_path = p_self_path;
-	GDScriptTokenizerText *tt = memnew(GDScriptTokenizerText);
+	CScriptTokenizerText *tt = memnew(CScriptTokenizerText);
 	tt->set_code(p_code);
 
 	validating = p_just_validate;
@@ -8823,15 +8823,15 @@ Error GDScriptParser::parse(const String &p_code, const String &p_base_path, boo
 	return ret;
 }
 
-bool GDScriptParser::is_tool_script() const {
+bool CScriptParser::is_tool_script() const {
 	return (head && head->type == Node::TYPE_CLASS && static_cast<const ClassNode *>(head)->tool);
 }
 
-const GDScriptParser::Node *GDScriptParser::get_parse_tree() const {
+const CScriptParser::Node *CScriptParser::get_parse_tree() const {
 	return head;
 }
 
-void GDScriptParser::clear() {
+void CScriptParser::clear() {
 	while (list) {
 		Node *l = list;
 		list = list->next;
@@ -8873,47 +8873,47 @@ void GDScriptParser::clear() {
 #endif // DEBUG_ENABLED
 }
 
-GDScriptParser::CompletionType GDScriptParser::get_completion_type() {
+CScriptParser::CompletionType CScriptParser::get_completion_type() {
 	return completion_type;
 }
 
-StringName GDScriptParser::get_completion_cursor() {
+StringName CScriptParser::get_completion_cursor() {
 	return completion_cursor;
 }
 
-int GDScriptParser::get_completion_line() {
+int CScriptParser::get_completion_line() {
 	return completion_line;
 }
 
-Variant::Type GDScriptParser::get_completion_built_in_constant() {
+Variant::Type CScriptParser::get_completion_built_in_constant() {
 	return completion_built_in_constant;
 }
 
-GDScriptParser::Node *GDScriptParser::get_completion_node() {
+CScriptParser::Node *CScriptParser::get_completion_node() {
 	return completion_node;
 }
 
-GDScriptParser::BlockNode *GDScriptParser::get_completion_block() {
+CScriptParser::BlockNode *CScriptParser::get_completion_block() {
 	return completion_block;
 }
 
-GDScriptParser::ClassNode *GDScriptParser::get_completion_class() {
+CScriptParser::ClassNode *CScriptParser::get_completion_class() {
 	return completion_class;
 }
 
-GDScriptParser::FunctionNode *GDScriptParser::get_completion_function() {
+CScriptParser::FunctionNode *CScriptParser::get_completion_function() {
 	return completion_function;
 }
 
-int GDScriptParser::get_completion_argument_index() {
+int CScriptParser::get_completion_argument_index() {
 	return completion_argument;
 }
 
-int GDScriptParser::get_completion_identifier_is_function() {
+int CScriptParser::get_completion_identifier_is_function() {
 	return completion_ident_is_call;
 }
 
-GDScriptParser::GDScriptParser() {
+CScriptParser::CScriptParser() {
 	head = nullptr;
 	list = nullptr;
 	tokenizer = nullptr;
@@ -8921,6 +8921,6 @@ GDScriptParser::GDScriptParser() {
 	clear();
 }
 
-GDScriptParser::~GDScriptParser() {
+CScriptParser::~CScriptParser() {
 	clear();
 }
diff --git a/modules/cscript/cscript_parser.h b/modules/cscript/cscript_parser.h
index 7b706b784..a0c93def2 100644
--- a/modules/cscript/cscript_parser.h
+++ b/modules/cscript/cscript_parser.h
@@ -36,10 +36,10 @@
 #include "cscript_functions.h"
 #include "cscript_tokenizer.h"
 
-struct GDScriptDataType;
-struct GDScriptWarning;
+struct CScriptDataType;
+struct CScriptWarning;
 
-class GDScriptParser {
+class CScriptParser {
 public:
 	struct ClassNode;
 
@@ -48,7 +48,7 @@ public:
 			BUILTIN,
 			NATIVE,
 			SCRIPT,
-			GDSCRIPT,
+			CSCRIPT,
 			CLASS,
 			UNRESOLVED
 		} kind;
@@ -80,7 +80,7 @@ public:
 				case NATIVE: {
 					return native_type == other.native_type;
 				} break;
-				case GDSCRIPT:
+				case CSCRIPT:
 				case SCRIPT: {
 					return script_type == other.script_type;
 				} break;
@@ -264,7 +264,7 @@ public:
 		TypeNode() { type = TYPE_TYPE; }
 	};
 	struct BuiltInFunctionNode : public Node {
-		GDScriptFunctions::Function function;
+		CScriptFunctions::Function function;
 		BuiltInFunctionNode() { type = TYPE_BUILT_IN_FUNCTION; }
 	};
 
@@ -520,7 +520,7 @@ public:
 	};
 
 private:
-	GDScriptTokenizer *tokenizer;
+	CScriptTokenizer *tokenizer;
 
 	Node *head;
 	Node *list;
@@ -542,7 +542,7 @@ private:
 #endif // DEBUG_ENABLED
 
 #ifdef DEBUG_ENABLED
-	List<GDScriptWarning> warnings;
+	List<CScriptWarning> warnings;
 #endif // DEBUG_ENABLED
 
 	int pending_newline;
@@ -626,7 +626,7 @@ private:
 	DataType _resolve_type(const DataType &p_source, int p_line);
 	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_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;
 	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;
@@ -664,7 +664,7 @@ public:
 	int get_error_line() const;
 	int get_error_column() const;
 #ifdef DEBUG_ENABLED
-	const List<GDScriptWarning> &get_warnings() const {
+	const List<CScriptWarning> &get_warnings() const {
 		return warnings;
 	}
 #endif // DEBUG_ENABLED
@@ -692,8 +692,8 @@ public:
 	}
 
 	void clear();
-	GDScriptParser();
-	~GDScriptParser();
+	CScriptParser();
+	~CScriptParser();
 };
 
-#endif // GDSCRIPT_PARSER_H
+#endif // CSCRIPT_PARSER_H
diff --git a/modules/cscript/cscript_tokenizer.cpp b/modules/cscript/cscript_tokenizer.cpp
index fd2b4e10b..000e4099c 100644
--- a/modules/cscript/cscript_tokenizer.cpp
+++ b/modules/cscript/cscript_tokenizer.cpp
@@ -35,7 +35,7 @@
 #include "core/print_string.h"
 #include "cscript_functions.h"
 
-const char *GDScriptTokenizer::token_names[TK_MAX] = {
+const char *CScriptTokenizer::token_names[TK_MAX] = {
 	"Empty",
 	"Identifier",
 	"Constant",
@@ -182,71 +182,71 @@ static const _bit _type_list[] = {
 };
 
 struct _kws {
-	GDScriptTokenizer::Token token;
+	CScriptTokenizer::Token token;
 	const char *text;
 };
 
 static const _kws _keyword_list[] = {
 	//ops
-	{ GDScriptTokenizer::TK_OP_IN, "in" },
-	{ GDScriptTokenizer::TK_OP_NOT, "not" },
-	{ GDScriptTokenizer::TK_OP_OR, "or" },
-	{ GDScriptTokenizer::TK_OP_AND, "and" },
+	{ CScriptTokenizer::TK_OP_IN, "in" },
+	{ CScriptTokenizer::TK_OP_NOT, "not" },
+	{ CScriptTokenizer::TK_OP_OR, "or" },
+	{ CScriptTokenizer::TK_OP_AND, "and" },
 	//func
-	{ GDScriptTokenizer::TK_PR_FUNCTION, "func" },
-	{ GDScriptTokenizer::TK_PR_CLASS, "class" },
-	{ GDScriptTokenizer::TK_PR_CLASS_NAME, "class_name" },
-	{ GDScriptTokenizer::TK_PR_EXTENDS, "extends" },
-	{ GDScriptTokenizer::TK_PR_IS, "is" },
-	{ GDScriptTokenizer::TK_PR_ONREADY, "onready" },
-	{ GDScriptTokenizer::TK_PR_TOOL, "tool" },
-	{ GDScriptTokenizer::TK_PR_STATIC, "static" },
-	{ GDScriptTokenizer::TK_PR_EXPORT, "export" },
-	{ GDScriptTokenizer::TK_PR_SETGET, "setget" },
-	{ GDScriptTokenizer::TK_PR_VAR, "var" },
-	{ GDScriptTokenizer::TK_PR_AS, "as" },
-	{ GDScriptTokenizer::TK_PR_VOID, "void" },
-	{ GDScriptTokenizer::TK_PR_PRELOAD, "preload" },
-	{ GDScriptTokenizer::TK_PR_ASSERT, "assert" },
-	{ GDScriptTokenizer::TK_PR_YIELD, "yield" },
-	{ GDScriptTokenizer::TK_PR_SIGNAL, "signal" },
-	{ GDScriptTokenizer::TK_PR_BREAKPOINT, "breakpoint" },
-	{ GDScriptTokenizer::TK_PR_REMOTE, "remote" },
-	{ GDScriptTokenizer::TK_PR_MASTER, "master" },
-	{ GDScriptTokenizer::TK_PR_SLAVE, "slave" },
-	{ GDScriptTokenizer::TK_PR_PUPPET, "puppet" },
-	{ GDScriptTokenizer::TK_PR_SYNC, "sync" },
-	{ GDScriptTokenizer::TK_PR_REMOTESYNC, "remotesync" },
-	{ GDScriptTokenizer::TK_PR_MASTERSYNC, "mastersync" },
-	{ GDScriptTokenizer::TK_PR_PUPPETSYNC, "puppetsync" },
-	{ GDScriptTokenizer::TK_PR_CONST, "const" },
-	{ GDScriptTokenizer::TK_PR_ENUM, "enum" },
+	{ CScriptTokenizer::TK_PR_FUNCTION, "func" },
+	{ CScriptTokenizer::TK_PR_CLASS, "class" },
+	{ CScriptTokenizer::TK_PR_CLASS_NAME, "class_name" },
+	{ CScriptTokenizer::TK_PR_EXTENDS, "extends" },
+	{ CScriptTokenizer::TK_PR_IS, "is" },
+	{ CScriptTokenizer::TK_PR_ONREADY, "onready" },
+	{ CScriptTokenizer::TK_PR_TOOL, "tool" },
+	{ CScriptTokenizer::TK_PR_STATIC, "static" },
+	{ CScriptTokenizer::TK_PR_EXPORT, "export" },
+	{ CScriptTokenizer::TK_PR_SETGET, "setget" },
+	{ CScriptTokenizer::TK_PR_VAR, "var" },
+	{ CScriptTokenizer::TK_PR_AS, "as" },
+	{ CScriptTokenizer::TK_PR_VOID, "void" },
+	{ CScriptTokenizer::TK_PR_PRELOAD, "preload" },
+	{ CScriptTokenizer::TK_PR_ASSERT, "assert" },
+	{ CScriptTokenizer::TK_PR_YIELD, "yield" },
+	{ CScriptTokenizer::TK_PR_SIGNAL, "signal" },
+	{ CScriptTokenizer::TK_PR_BREAKPOINT, "breakpoint" },
+	{ CScriptTokenizer::TK_PR_REMOTE, "remote" },
+	{ CScriptTokenizer::TK_PR_MASTER, "master" },
+	{ CScriptTokenizer::TK_PR_SLAVE, "slave" },
+	{ CScriptTokenizer::TK_PR_PUPPET, "puppet" },
+	{ CScriptTokenizer::TK_PR_SYNC, "sync" },
+	{ CScriptTokenizer::TK_PR_REMOTESYNC, "remotesync" },
+	{ CScriptTokenizer::TK_PR_MASTERSYNC, "mastersync" },
+	{ CScriptTokenizer::TK_PR_PUPPETSYNC, "puppetsync" },
+	{ CScriptTokenizer::TK_PR_CONST, "const" },
+	{ CScriptTokenizer::TK_PR_ENUM, "enum" },
 	//controlflow
-	{ GDScriptTokenizer::TK_CF_IF, "if" },
-	{ GDScriptTokenizer::TK_CF_ELIF, "elif" },
-	{ GDScriptTokenizer::TK_CF_ELSE, "else" },
-	{ GDScriptTokenizer::TK_CF_FOR, "for" },
-	{ GDScriptTokenizer::TK_CF_WHILE, "while" },
-	{ GDScriptTokenizer::TK_CF_BREAK, "break" },
-	{ GDScriptTokenizer::TK_CF_CONTINUE, "continue" },
-	{ GDScriptTokenizer::TK_CF_RETURN, "return" },
-	{ GDScriptTokenizer::TK_CF_MATCH, "match" },
-	{ GDScriptTokenizer::TK_CF_PASS, "pass" },
-	{ GDScriptTokenizer::TK_SELF, "self" },
-	{ GDScriptTokenizer::TK_CONST_PI, "PI" },
-	{ GDScriptTokenizer::TK_CONST_TAU, "TAU" },
-	{ GDScriptTokenizer::TK_WILDCARD, "_" },
-	{ GDScriptTokenizer::TK_CONST_INF, "INF" },
-	{ GDScriptTokenizer::TK_CONST_NAN, "NAN" },
-	{ GDScriptTokenizer::TK_ERROR, nullptr }
+	{ CScriptTokenizer::TK_CF_IF, "if" },
+	{ CScriptTokenizer::TK_CF_ELIF, "elif" },
+	{ CScriptTokenizer::TK_CF_ELSE, "else" },
+	{ CScriptTokenizer::TK_CF_FOR, "for" },
+	{ CScriptTokenizer::TK_CF_WHILE, "while" },
+	{ CScriptTokenizer::TK_CF_BREAK, "break" },
+	{ CScriptTokenizer::TK_CF_CONTINUE, "continue" },
+	{ CScriptTokenizer::TK_CF_RETURN, "return" },
+	{ CScriptTokenizer::TK_CF_MATCH, "match" },
+	{ CScriptTokenizer::TK_CF_PASS, "pass" },
+	{ CScriptTokenizer::TK_SELF, "self" },
+	{ CScriptTokenizer::TK_CONST_PI, "PI" },
+	{ CScriptTokenizer::TK_CONST_TAU, "TAU" },
+	{ CScriptTokenizer::TK_WILDCARD, "_" },
+	{ CScriptTokenizer::TK_CONST_INF, "INF" },
+	{ CScriptTokenizer::TK_CONST_NAN, "NAN" },
+	{ 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>");
 	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)) {
 		// Can always be literal:
 		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);
 	switch (token) {
 		case TK_IDENTIFIER:
@@ -335,7 +335,7 @@ StringName GDScriptTokenizer::get_token_literal(int p_offset) const {
 			}
 		} break; // Shouldn't get here, stuff happens
 		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: {
 			const Variant value = get_token_constant(p_offset);
 
@@ -381,7 +381,7 @@ static bool _is_bin(CharType c) {
 	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];
 
 	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;
 }
-void GDScriptTokenizerText::_make_identifier(const StringName &p_identifier) {
+void CScriptTokenizerText::_make_identifier(const StringName &p_identifier) {
 	TokenData &tk = tk_rb[tk_rb_pos];
 
 	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;
 }
 
-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];
 
 	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;
 }
-void GDScriptTokenizerText::_make_constant(const Variant &p_constant) {
+void CScriptTokenizerText::_make_constant(const Variant &p_constant) {
 	TokenData &tk = tk_rb[tk_rb_pos];
 
 	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;
 }
 
-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];
 
 	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;
 }
 
-void GDScriptTokenizerText::_make_error(const String &p_error) {
+void CScriptTokenizerText::_make_error(const String &p_error) {
 	error_flag = true;
 	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;
 }
 
-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];
 	tk.type = TK_NEWLINE;
 	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;
 }
 
-void GDScriptTokenizerText::_advance() {
+void CScriptTokenizerText::_advance() {
 	if (error_flag) {
 		//parser broke
 		_make_error(last_error);
@@ -1012,9 +1012,9 @@ void GDScriptTokenizerText::_advance() {
 						if (!found) {
 							//built in func?
 
-							for (int j = 0; j < GDScriptFunctions::FUNC_MAX; j++) {
-								if (str == GDScriptFunctions::get_func_name(GDScriptFunctions::Function(j))) {
-									_make_built_in_func(GDScriptFunctions::Function(j));
+							for (int j = 0; j < CScriptFunctions::FUNC_MAX; j++) {
+								if (str == CScriptFunctions::get_func_name(CScriptFunctions::Function(j))) {
+									_make_built_in_func(CScriptFunctions::Function(j));
 									found = true;
 									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;
 	len = p_code.length();
 	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);
 
@@ -1090,7 +1090,7 @@ GDScriptTokenizerText::Token GDScriptTokenizerText::get_token(int p_offset) cons
 	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);
 
@@ -1098,7 +1098,7 @@ int GDScriptTokenizerText::get_token_line(int p_offset) const {
 	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);
 
@@ -1106,7 +1106,7 @@ int GDScriptTokenizerText::get_token_column(int p_offset) const {
 	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);
 
@@ -1115,7 +1115,7 @@ const Variant &GDScriptTokenizerText::get_token_constant(int p_offset) const {
 	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());
 
@@ -1124,16 +1124,16 @@ StringName GDScriptTokenizerText::get_token_identifier(int p_offset) const {
 	return tk_rb[ofs].identifier;
 }
 
-GDScriptFunctions::Function GDScriptTokenizerText::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, GDScriptFunctions::FUNC_MAX);
+CScriptFunctions::Function CScriptTokenizerText::get_token_built_in_func(int p_offset) const {
+	ERR_FAIL_COND_V(p_offset <= -MAX_LOOKAHEAD, CScriptFunctions::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;
-	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;
 }
 
-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);
 
@@ -1142,7 +1142,7 @@ Variant::Type GDScriptTokenizerText::get_token_type(int p_offset) const {
 	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);
 
@@ -1151,7 +1151,7 @@ int GDScriptTokenizerText::get_token_line_indent(int p_offset) const {
 	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);
 
@@ -1160,7 +1160,7 @@ int GDScriptTokenizerText::get_token_line_tab_indent(int p_offset) const {
 	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());
 
@@ -1169,7 +1169,7 @@ String GDScriptTokenizerText::get_token_error(int p_offset) const {
 	return tk_rb[ofs].constant;
 }
 
-void GDScriptTokenizerText::advance(int p_amount) {
+void CScriptTokenizerText::advance(int p_amount) {
 	ERR_FAIL_COND(p_amount <= 0);
 	for (int i = 0; i < p_amount; i++) {
 		_advance();
@@ -1180,7 +1180,7 @@ void GDScriptTokenizerText::advance(int p_amount) {
 
 #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();
 	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);
@@ -1263,7 +1263,7 @@ Error GDScriptTokenizerBuffer::set_code_buffer(const Vector<uint8_t> &p_buffer)
 	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;
 
 	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;
 	Vector<uint32_t> token_array;
 
-	GDScriptTokenizerText tt;
+	CScriptTokenizerText tt;
 	tt.set_code(p_code);
 	int line = -1;
 
@@ -1413,17 +1413,17 @@ Vector<uint8_t> GDScriptTokenizerBuffer::parse_code_string(const String &p_code)
 	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;
 
 	if (offset < 0 || offset >= tokens.size()) {
 		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;
 
 	ERR_FAIL_INDEX_V(offset, tokens.size(), StringName());
@@ -1433,20 +1433,20 @@ StringName GDScriptTokenizerBuffer::get_token_identifier(int p_offset) const {
 	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;
-	ERR_FAIL_INDEX_V(offset, tokens.size(), GDScriptFunctions::FUNC_MAX);
-	return GDScriptFunctions::Function(tokens[offset] >> TOKEN_BITS);
+	ERR_FAIL_INDEX_V(offset, tokens.size(), CScriptFunctions::FUNC_MAX);
+	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;
 	ERR_FAIL_INDEX_V(offset, tokens.size(), Variant::NIL);
 
 	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 pos = lines.find_nearest(offset);
 
@@ -1460,7 +1460,7 @@ int GDScriptTokenizerBuffer::get_token_line(int p_offset) const {
 	uint32_t l = lines.getv(pos);
 	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 pos = lines.find_nearest(offset);
 	if (pos < 0) {
@@ -1473,26 +1473,26 @@ int GDScriptTokenizerBuffer::get_token_column(int p_offset) const {
 	uint32_t l = lines.getv(pos);
 	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;
 	ERR_FAIL_INDEX_V(offset, tokens.size(), 0);
 	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;
 	ERR_FAIL_INDEX_V(offset, tokens.size(), nil);
 	uint32_t constant = tokens[offset] >> TOKEN_BITS;
 	ERR_FAIL_UNSIGNED_INDEX_V(constant, (uint32_t)constants.size(), nil);
 	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());
 }
 
-void GDScriptTokenizerBuffer::advance(int p_amount) {
+void CScriptTokenizerBuffer::advance(int p_amount) {
 	ERR_FAIL_INDEX(p_amount + token, tokens.size());
 	token += p_amount;
 }
-GDScriptTokenizerBuffer::GDScriptTokenizerBuffer() {
+CScriptTokenizerBuffer::CScriptTokenizerBuffer() {
 	token = 0;
 }
diff --git a/modules/cscript/cscript_tokenizer.h b/modules/cscript/cscript_tokenizer.h
index 6859baa05..704554696 100644
--- a/modules/cscript/cscript_tokenizer.h
+++ b/modules/cscript/cscript_tokenizer.h
@@ -37,7 +37,7 @@
 #include "core/vmap.h"
 #include "cscript_functions.h"
 
-class GDScriptTokenizer {
+class CScriptTokenizer {
 public:
 	enum Token {
 
@@ -162,7 +162,7 @@ public:
 	virtual const Variant &get_token_constant(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 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 int get_token_line(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;
 #endif // DEBUG_ENABLED
 
-	virtual ~GDScriptTokenizer(){};
+	virtual ~CScriptTokenizer(){};
 };
 
-class GDScriptTokenizerText : public GDScriptTokenizer {
+class CScriptTokenizerText : public CScriptTokenizer {
 	enum {
 		MAX_LOOKAHEAD = 4,
 		TK_RB_SIZE = MAX_LOOKAHEAD * 2 + 1
@@ -192,7 +192,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
 		Variant constant; //for constant types
 		union {
 			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 line, col;
@@ -206,7 +206,7 @@ class GDScriptTokenizerText : public GDScriptTokenizer {
 	void _make_token(Token p_type);
 	void _make_newline(int p_indentation = 0, int p_tabs = 0);
 	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_type(const Variant::Type &p_type);
 	void _make_error(const String &p_error);
@@ -234,7 +234,7 @@ public:
 	void set_code(const String &p_code);
 	virtual Token get_token(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 int get_token_line(int p_offset = 0) const;
 	virtual int get_token_column(int p_offset = 0) const;
@@ -256,7 +256,7 @@ public:
 #endif // DEBUG_ENABLED
 };
 
-class GDScriptTokenizerBuffer : public GDScriptTokenizer {
+class CScriptTokenizerBuffer : public CScriptTokenizer {
 	enum {
 
 		TOKEN_BYTE_MASK = 0x80,
@@ -278,7 +278,7 @@ public:
 	static Vector<uint8_t> parse_code_string(const String &p_code);
 	virtual Token get_token(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 int get_token_line(int p_offset = 0) const;
 	virtual int get_token_column(int p_offset = 0) const;
@@ -300,7 +300,7 @@ public:
 		return true;
 	}
 #endif // DEBUG_ENABLED
-	GDScriptTokenizerBuffer();
+	CScriptTokenizerBuffer();
 };
 
-#endif // GDSCRIPT_TOKENIZER_H
+#endif // CSCRIPT_TOKENIZER_H
diff --git a/modules/cscript/doc_classes/@CScript.xml b/modules/cscript/doc_classes/@CScript.xml
index cbe3934b4..99ee6299f 100644
--- a/modules/cscript/doc_classes/@CScript.xml
+++ b/modules/cscript/doc_classes/@CScript.xml
@@ -1,21 +1,20 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<class name="@GDScript" version="3.5">
-	<brief_description>
-		Built-in GDScript functions.
+<?xml version="1.0" encoding="UTF-8"?>
+<class name="@CScript" version="3.5">
+  <brief_description>
+		Built-in CScript functions.
 	</brief_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.)
+  <description>
+		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>
-	<tutorials>
-	</tutorials>
-	<methods>
-		<method name="Color8">
-			<return type="Color" />
-			<argument index="0" name="r8" type="int" />
-			<argument index="1" name="g8" type="int" />
-			<argument index="2" name="b8" type="int" />
-			<argument index="3" name="a8" type="int" default="255" />
-			<description>
+  <tutorials></tutorials>
+  <methods>
+    <method name="Color8">
+      <return type="Color" />
+      <argument index="0" name="r8" type="int" />
+      <argument index="1" name="g8" type="int" />
+      <argument index="2" name="b8" type="int" />
+      <argument index="3" name="a8" type="int" default="255" />
+      <description>
 				Returns a color constructed from integer red, green, blue, and alpha channels. Each channel should have 8 bits of information ranging from 0 to 255.
 				[code]r8[/code] red channel
 				[code]g8[/code] green channel
@@ -25,56 +24,56 @@
 				red = Color8(255, 0, 0)
 				[/codeblock]
 			</description>
-		</method>
-		<method name="ColorN">
-			<return type="Color" />
-			<argument index="0" name="name" type="String" />
-			<argument index="1" name="alpha" type="float" default="1.0" />
-			<description>
+    </method>
+    <method name="ColorN">
+      <return type="Color" />
+      <argument index="0" name="name" type="String" />
+      <argument index="1" name="alpha" type="float" default="1.0" />
+      <description>
 				Returns a color according to the standardized [code]name[/code] with [code]alpha[/code] ranging from 0 to 1.
 				[codeblock]
 				red = ColorN("red", 1)
 				[/codeblock]
 				Supported color names are the same as the constants defined in [Color].
 			</description>
-		</method>
-		<method name="abs">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="abs">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the absolute value of parameter [code]s[/code] (i.e. positive value).
 				[codeblock]
 				a = abs(-1) # a is 1
 				[/codeblock]
 			</description>
-		</method>
-		<method name="acos">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="acos">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the arc cosine of [code]s[/code] in radians. Use to get the angle of cosine [code]s[/code]. [code]s[/code] must be between [code]-1.0[/code] and [code]1.0[/code] (inclusive), otherwise, [method acos] will return [constant NAN].
 				[codeblock]
 				# c is 0.523599 or 30 degrees if converted with rad2deg(s)
 				c = acos(0.866025)
 				[/codeblock]
 			</description>
-		</method>
-		<method name="asin">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="asin">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the arc sine of [code]s[/code] in radians. Use to get the angle of sine [code]s[/code]. [code]s[/code] must be between [code]-1.0[/code] and [code]1.0[/code] (inclusive), otherwise, [method asin] will return [constant NAN].
 				[codeblock]
 				# s is 0.523599 or 30 degrees if converted with rad2deg(s)
 				s = asin(0.5)
 				[/codeblock]
 			</description>
-		</method>
-		<method name="assert">
-			<return type="void" />
-			<argument index="0" name="condition" type="bool" />
-			<argument index="1" name="message" type="String" default="&quot;&quot;" />
-			<description>
+    </method>
+    <method name="assert">
+      <return type="void" />
+      <argument index="0" name="condition" type="bool" />
+      <argument index="1" name="message" type="String" default="&quot;&quot;" />
+      <description>
 				Asserts that the [code]condition[/code] is [code]true[/code]. If the [code]condition[/code] is [code]false[/code], an error is generated. When running from the editor, the running project will also be paused until you resume it. This can be used as a stronger form of [method push_error] for reporting errors to project developers or add-on users.
 				[b]Note:[/b] For performance reasons, the code inside [method assert] is only executed in debug builds or when running the project from the editor. Don't include code that has side effects in an [method assert] call. Otherwise, the project will behave differently when exported in release mode.
 				The optional [code]message[/code] argument, if given, is shown in addition to the generic "Assertion failed" message. You can use this to provide additional details about why the assertion failed.
@@ -87,51 +86,51 @@
 				assert(speed &lt; 20, "speed = %f, but the speed limit is 20" % speed) # Show a message with clarifying details
 				[/codeblock]
 			</description>
-		</method>
-		<method name="atan">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="atan">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the arc tangent of [code]s[/code] in radians. Use it to get the angle from an angle's tangent in trigonometry: [code]atan(tan(angle)) == angle[/code].
 				The method cannot know in which quadrant the angle should fall. See [method atan2] if you have both [code]y[/code] and [code]x[/code].
 				[codeblock]
 				a = atan(0.5) # a is 0.463648
 				[/codeblock]
 			</description>
-		</method>
-		<method name="atan2">
-			<return type="float" />
-			<argument index="0" name="y" type="float" />
-			<argument index="1" name="x" type="float" />
-			<description>
+    </method>
+    <method name="atan2">
+      <return type="float" />
+      <argument index="0" name="y" type="float" />
+      <argument index="1" name="x" type="float" />
+      <description>
 				Returns the arc tangent of [code]y/x[/code] in radians. Use to get the angle of tangent [code]y/x[/code]. To compute the value, the method takes into account the sign of both arguments in order to determine the quadrant.
 				Important note: The Y coordinate comes first, by convention.
 				[codeblock]
 				a = atan2(0, -1) # a is 3.141593
 				[/codeblock]
 			</description>
-		</method>
-		<method name="bytes2var">
-			<return type="Variant" />
-			<argument index="0" name="bytes" type="PoolByteArray" />
-			<argument index="1" name="allow_objects" type="bool" default="false" />
-			<description>
+    </method>
+    <method name="bytes2var">
+      <return type="Variant" />
+      <argument index="0" name="bytes" type="PoolByteArray" />
+      <argument index="1" name="allow_objects" type="bool" default="false" />
+      <description>
 				Decodes a byte array back to a value. When [code]allow_objects[/code] is [code]true[/code] decoding objects is allowed.
 				[b]WARNING:[/b] Deserialized object can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats (remote code execution).
 			</description>
-		</method>
-		<method name="cartesian2polar">
-			<return type="Vector2" />
-			<argument index="0" name="x" type="float" />
-			<argument index="1" name="y" type="float" />
-			<description>
+    </method>
+    <method name="cartesian2polar">
+      <return type="Vector2" />
+      <argument index="0" name="x" type="float" />
+      <argument index="1" name="y" type="float" />
+      <description>
 				Converts a 2D point expressed in the cartesian coordinate system (X and Y axis) to the polar coordinate system (a distance from the origin and an angle).
 			</description>
-		</method>
-		<method name="ceil">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="ceil">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Rounds [code]s[/code] upward (towards positive infinity), returning the smallest whole number that is not less than [code]s[/code].
 				[codeblock]
 				a = ceil(1.45)  # a is 2.0
@@ -139,11 +138,11 @@
 				[/codeblock]
 				See also [method floor], [method round], [method stepify], and [int].
 			</description>
-		</method>
-		<method name="char">
-			<return type="String" />
-			<argument index="0" name="code" type="int" />
-			<description>
+    </method>
+    <method name="char">
+      <return type="String" />
+      <argument index="0" name="code" type="int" />
+      <description>
 				Returns a character as a String of the given Unicode code point (which is compatible with ASCII code).
 				[codeblock]
 				a = char(65)      # a is "A"
@@ -152,13 +151,13 @@
 				[/codeblock]
 				This is the inverse of [method ord].
 			</description>
-		</method>
-		<method name="clamp">
-			<return type="float" />
-			<argument index="0" name="value" type="float" />
-			<argument index="1" name="min" type="float" />
-			<argument index="2" name="max" type="float" />
-			<description>
+    </method>
+    <method name="clamp">
+      <return type="float" />
+      <argument index="0" name="value" type="float" />
+      <argument index="1" name="min" type="float" />
+      <argument index="2" name="max" type="float" />
+      <description>
 				Clamps [code]value[/code] and returns a value not less than [code]min[/code] and not more than [code]max[/code].
 				[codeblock]
 				a = clamp(1000, 1, 20) # a is 20
@@ -166,12 +165,12 @@
 				a = clamp(15, 1, 20)   # a is 15
 				[/codeblock]
 			</description>
-		</method>
-		<method name="convert">
-			<return type="Variant" />
-			<argument index="0" name="what" type="Variant" />
-			<argument index="1" name="type" type="int" />
-			<description>
+    </method>
+    <method name="convert">
+      <return type="Variant" />
+      <argument index="0" name="what" type="Variant" />
+      <argument index="1" name="type" type="int" />
+      <description>
 				Converts from a type to another in the best way possible. The [code]type[/code] parameter uses the [enum Variant.Type] values.
 				[codeblock]
 				a = Vector2(1, 0)
@@ -182,60 +181,60 @@
 				print(a.length())
 				[/codeblock]
 			</description>
-		</method>
-		<method name="cos">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="cos">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the cosine of angle [code]s[/code] in radians.
 				[codeblock]
 				a = cos(TAU) # a is 1.0
 				a = cos(PI)  # a is -1.0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="cosh">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="cosh">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the hyperbolic cosine of [code]s[/code] in radians.
 				[codeblock]
 				print(cosh(1)) # Prints 1.543081
 				[/codeblock]
 			</description>
-		</method>
-		<method name="db2linear">
-			<return type="float" />
-			<argument index="0" name="db" type="float" />
-			<description>
+    </method>
+    <method name="db2linear">
+      <return type="float" />
+      <argument index="0" name="db" type="float" />
+      <description>
 				Converts from decibels to linear energy (audio).
 			</description>
-		</method>
-		<method name="decimals">
-			<return type="int" />
-			<argument index="0" name="step" type="float" />
-			<description>
+    </method>
+    <method name="decimals">
+      <return type="int" />
+      <argument index="0" name="step" type="float" />
+      <description>
 				Deprecated alias for [method step_decimals].
 			</description>
-		</method>
-		<method name="dectime">
-			<return type="float" />
-			<argument index="0" name="value" type="float" />
-			<argument index="1" name="amount" type="float" />
-			<argument index="2" name="step" type="float" />
-			<description>
+    </method>
+    <method name="dectime">
+      <return type="float" />
+      <argument index="0" name="value" type="float" />
+      <argument index="1" name="amount" type="float" />
+      <argument index="2" name="step" type="float" />
+      <description>
 				[b]Note:[/b] [code]dectime[/code] has been deprecated and will be removed in Pandemonium 4.0, please use [method move_toward] instead.
 				Returns the result of [code]value[/code] decreased by [code]step[/code] * [code]amount[/code].
 				[codeblock]
 				a = dectime(60, 10, 0.1)) # a is 59.0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="deep_equal">
-			<return type="bool" />
-			<argument index="0" name="a" type="Variant" />
-			<argument index="1" name="b" type="Variant" />
-			<description>
+    </method>
+    <method name="deep_equal">
+      <return type="bool" />
+      <argument index="0" name="a" type="Variant" />
+      <argument index="1" name="b" type="Variant" />
+      <description>
 				Compares two values by checking their actual contents, recursing into any `Array` or `Dictionary` up to its deepest level.
 				This compares to [code]==[/code] in a number of ways:
 				- For [code]null[/code], [code]int[/code], [code]float[/code], [code]String[/code], [code]Object[/code] and [code]RID[/code] both [code]deep_equal[/code] and [code]==[/code] work the same.
@@ -243,29 +242,29 @@
 				- For [code]Array[/code], [code]==[/code] considers equality if, and only if, each item in the first [code]Array[/code] is equal to its counterpart in the second [code]Array[/code], as told by [code]==[/code] itself. That implies that [code]==[/code] recurses into [code]Array[/code], but not into [code]Dictionary[/code].
 				In short, whenever a [code]Dictionary[/code] is potentially involved, if you want a true content-aware comparison, you have to use [code]deep_equal[/code].
 			</description>
-		</method>
-		<method name="deg2rad">
-			<return type="float" />
-			<argument index="0" name="deg" type="float" />
-			<description>
+    </method>
+    <method name="deg2rad">
+      <return type="float" />
+      <argument index="0" name="deg" type="float" />
+      <description>
 				Converts an angle expressed in degrees to radians.
 				[codeblock]
 				r = deg2rad(180) # r is 3.141593
 				[/codeblock]
 			</description>
-		</method>
-		<method name="dict2inst">
-			<return type="Object" />
-			<argument index="0" name="dict" type="Dictionary" />
-			<description>
+    </method>
+    <method name="dict2inst">
+      <return type="Object" />
+      <argument index="0" name="dict" type="Dictionary" />
+      <description>
 				Converts a dictionary (previously created with [method inst2dict]) back to an instance. Useful for deserializing.
 			</description>
-		</method>
-		<method name="ease">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<argument index="1" name="curve" type="float" />
-			<description>
+    </method>
+    <method name="ease">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <argument index="1" name="curve" type="float" />
+      <description>
 				Returns an "eased" value of [code]x[/code] based on an easing function defined with [code]curve[/code]. This easing function is based on an exponent. The [code]curve[/code] can be any floating-point number, with specific values leading to the following behaviors:
 				[codeblock]
 				- Lower than -1.0 (exclusive): Ease in-out
@@ -279,11 +278,11 @@
 				[url=https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/ease_cheatsheet.png]ease() curve values cheatsheet[/url]
 				See also [method smoothstep]. If you need to perform more advanced transitions, use [Tween] or [AnimationPlayer].
 			</description>
-		</method>
-		<method name="exp">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="exp">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				The natural exponential function. It raises the mathematical constant [b]e[/b] to the power of [code]s[/code] and returns it.
 				[b]e[/b] has an approximate value of 2.71828, and can be obtained with [code]exp(1)[/code].
 				For exponents to other bases use the method [method pow].
@@ -291,11 +290,11 @@
 				a = exp(2) # Approximately 7.39
 				[/codeblock]
 			</description>
-		</method>
-		<method name="floor">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="floor">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Rounds [code]s[/code] downward (towards negative infinity), returning the largest whole number that is not more than [code]s[/code].
 				[codeblock]
 				a = floor(2.45)  # a is 2.0
@@ -305,24 +304,24 @@
 				See also [method ceil], [method round], [method stepify], and [int].
 				[b]Note:[/b] This method returns a float. If you need an integer and [code]s[/code] is a non-negative number, you can use [code]int(s)[/code] directly.
 			</description>
-		</method>
-		<method name="fmod">
-			<return type="float" />
-			<argument index="0" name="a" type="float" />
-			<argument index="1" name="b" type="float" />
-			<description>
+    </method>
+    <method name="fmod">
+      <return type="float" />
+      <argument index="0" name="a" type="float" />
+      <argument index="1" name="b" type="float" />
+      <description>
 				Returns the floating-point remainder of [code]a/b[/code], keeping the sign of [code]a[/code].
 				[codeblock]
 				r = fmod(7, 5.5) # r is 1.5
 				[/codeblock]
 				For the integer remainder operation, use the % operator.
 			</description>
-		</method>
-		<method name="fposmod">
-			<return type="float" />
-			<argument index="0" name="a" type="float" />
-			<argument index="1" name="b" type="float" />
-			<description>
+    </method>
+    <method name="fposmod">
+      <return type="float" />
+      <argument index="0" name="a" type="float" />
+      <argument index="1" name="b" type="float" />
+      <description>
 				Returns the floating-point modulus of [code]a/b[/code] that wraps equally in positive and negative.
 				[codeblock]
 				for i in 7:
@@ -340,12 +339,12 @@
 				 1.5  0.0  0.0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="funcref">
-			<return type="FuncRef" />
-			<argument index="0" name="instance" type="Object" />
-			<argument index="1" name="funcname" type="String" />
-			<description>
+    </method>
+    <method name="funcref">
+      <return type="FuncRef" />
+      <argument index="0" name="instance" type="Object" />
+      <argument index="1" name="funcname" type="String" />
+      <description>
 				Returns a reference to the specified function [code]funcname[/code] in the [code]instance[/code] node. As functions aren't first-class objects in GDscript, use [code]funcref[/code] to store a [FuncRef] in a variable and call it later.
 				[codeblock]
 				func foo():
@@ -355,10 +354,10 @@
 				print(a.call_func()) # Prints bar
 				[/codeblock]
 			</description>
-		</method>
-		<method name="get_stack">
-			<return type="Array" />
-			<description>
+    </method>
+    <method name="get_stack">
+      <return type="Array" />
+      <description>
 				Returns an array of dictionaries representing the current call stack.
 				[codeblock]
 				func _ready():
@@ -375,21 +374,21 @@
 				[{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]
 				[/codeblock]
 			</description>
-		</method>
-		<method name="hash">
-			<return type="int" />
-			<argument index="0" name="var" type="Variant" />
-			<description>
+    </method>
+    <method name="hash">
+      <return type="int" />
+      <argument index="0" name="var" type="Variant" />
+      <description>
 				Returns the integer hash of the variable passed.
 				[codeblock]
 				print(hash("a")) # Prints 177670
 				[/codeblock]
 			</description>
-		</method>
-		<method name="inst2dict">
-			<return type="Dictionary" />
-			<argument index="0" name="inst" type="Object" />
-			<description>
+    </method>
+    <method name="inst2dict">
+      <return type="Dictionary" />
+      <argument index="0" name="inst" type="Object" />
+      <description>
 				Returns the passed instance converted to a dictionary (useful for serializing).
 				[codeblock]
 				var foo = "bar"
@@ -404,11 +403,11 @@
 				[, res://test.gd, bar]
 				[/codeblock]
 			</description>
-		</method>
-		<method name="instance_from_id">
-			<return type="Object" />
-			<argument index="0" name="instance_id" type="int" />
-			<description>
+    </method>
+    <method name="instance_from_id">
+      <return type="Object" />
+      <argument index="0" name="instance_id" type="int" />
+      <description>
 				Returns the Object that corresponds to [code]instance_id[/code]. All Objects have a unique instance ID.
 				[codeblock]
 				var foo = "bar"
@@ -418,13 +417,13 @@
 				    print(inst.foo) # Prints bar
 				[/codeblock]
 			</description>
-		</method>
-		<method name="inverse_lerp">
-			<return type="float" />
-			<argument index="0" name="from" type="float" />
-			<argument index="1" name="to" type="float" />
-			<argument index="2" name="weight" type="float" />
-			<description>
+    </method>
+    <method name="inverse_lerp">
+      <return type="float" />
+      <argument index="0" name="from" type="float" />
+      <argument index="1" name="to" type="float" />
+      <argument index="2" name="weight" type="float" />
+      <description>
 				Returns an interpolation or extrapolation factor considering the range specified in [code]from[/code] and [code]to[/code], and the interpolated value specified in [code]weight[/code]. The returned value will be between [code]0.0[/code] and [code]1.0[/code] if [code]weight[/code] is between [code]from[/code] and [code]to[/code] (inclusive). If [code]weight[/code] is located outside this range, then an extrapolation factor will be returned (return value lower than [code]0.0[/code] or greater than [code]1.0[/code]).
 				[codeblock]
 				# The interpolation ratio in the `lerp()` call below is 0.75.
@@ -436,50 +435,50 @@
 				[/codeblock]
 				See also [method lerp] which performs the reverse of this operation.
 			</description>
-		</method>
-		<method name="is_equal_approx">
-			<return type="bool" />
-			<argument index="0" name="a" type="float" />
-			<argument index="1" name="b" type="float" />
-			<description>
+    </method>
+    <method name="is_equal_approx">
+      <return type="bool" />
+      <argument index="0" name="a" type="float" />
+      <argument index="1" name="b" type="float" />
+      <description>
 				Returns [code]true[/code] if [code]a[/code] and [code]b[/code] are approximately equal to each other.
 				Here, approximately equal means that [code]a[/code] and [code]b[/code] are within a small internal epsilon of each other, which scales with the magnitude of the numbers.
 				Infinity values of the same sign are considered equal.
 			</description>
-		</method>
-		<method name="is_inf">
-			<return type="bool" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="is_inf">
+      <return type="bool" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns whether [code]s[/code] is an infinity value (either positive infinity or negative infinity).
 			</description>
-		</method>
-		<method name="is_instance_valid">
-			<return type="bool" />
-			<argument index="0" name="instance" type="Object" />
-			<description>
+    </method>
+    <method name="is_instance_valid">
+      <return type="bool" />
+      <argument index="0" name="instance" type="Object" />
+      <description>
 				Returns whether [code]instance[/code] is a valid object (e.g. has not been deleted from memory).
 			</description>
-		</method>
-		<method name="is_nan">
-			<return type="bool" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="is_nan">
+      <return type="bool" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns whether [code]s[/code] is a NaN ("Not a Number" or invalid) value.
 			</description>
-		</method>
-		<method name="is_zero_approx">
-			<return type="bool" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="is_zero_approx">
+      <return type="bool" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns [code]true[/code] if [code]s[/code] is zero or almost zero.
 				This method is faster than using [method is_equal_approx] with one value as zero.
 			</description>
-		</method>
-		<method name="len">
-			<return type="int" />
-			<argument index="0" name="var" type="Variant" />
-			<description>
+    </method>
+    <method name="len">
+      <return type="int" />
+      <argument index="0" name="var" type="Variant" />
+      <description>
 				Returns length of Variant [code]var[/code]. Length is the character count of String, element count of Array, size of Dictionary, etc.
 				[b]Note:[/b] Generates a fatal error if Variant can not provide a length.
 				[codeblock]
@@ -487,13 +486,13 @@
 				len(a) # Returns 4
 				[/codeblock]
 			</description>
-		</method>
-		<method name="lerp">
-			<return type="Variant" />
-			<argument index="0" name="from" type="Variant" />
-			<argument index="1" name="to" type="Variant" />
-			<argument index="2" name="weight" type="float" />
-			<description>
+    </method>
+    <method name="lerp">
+      <return type="Variant" />
+      <argument index="0" name="from" type="Variant" />
+      <argument index="1" name="to" type="Variant" />
+      <argument index="2" name="weight" type="float" />
+      <description>
 				Linearly interpolates between two values by the factor defined in [code]weight[/code]. To perform interpolation, [code]weight[/code] should be between [code]0.0[/code] and [code]1.0[/code] (inclusive). However, values outside this range are allowed and can be used to perform [i]extrapolation[/i].
 				If the [code]from[/code] and [code]to[/code] arguments are of type [int] or [float], the return value is a [float].
 				If both are of the same vector type ([Vector2], [Vector3] or [Color]), the return value will be of the same type ([code]lerp[/code] then calls the vector type's [code]linear_interpolate[/code] method).
@@ -503,15 +502,15 @@
 				[/codeblock]
 				See also [method inverse_lerp] which performs the reverse of this operation. To perform eased interpolation with [method lerp], combine it with [method ease] or [method smoothstep].
 			</description>
-		</method>
-		<method name="lerp_angle">
-			<return type="float" />
-			<argument index="0" name="from" type="float" />
-			<argument index="1" name="to" type="float" />
-			<argument index="2" name="weight" type="float" />
-			<description>
+    </method>
+    <method name="lerp_angle">
+      <return type="float" />
+      <argument index="0" name="from" type="float" />
+      <argument index="1" name="to" type="float" />
+      <argument index="2" name="weight" type="float" />
+      <description>
 				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]
 				extends Sprite
 				var elapsed = 0.0
@@ -522,11 +521,11 @@
 				    elapsed += delta
 				[/codeblock]
 			</description>
-		</method>
-		<method name="linear2db">
-			<return type="float" />
-			<argument index="0" name="nrg" type="float" />
-			<description>
+    </method>
+    <method name="linear2db">
+      <return type="float" />
+      <argument index="0" name="nrg" type="float" />
+      <description>
 				Converts from linear energy to decibels (audio). This can be used to implement volume sliders that behave as expected (since volume isn't linear). Example:
 				[codeblock]
 				# "Slider" refers to a node that inherits Range such as HSlider or VSlider.
@@ -535,11 +534,11 @@
 				AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))
 				[/codeblock]
 			</description>
-		</method>
-		<method name="load">
-			<return type="Resource" />
-			<argument index="0" name="path" type="String" />
-			<description>
+    </method>
+    <method name="load">
+      <return type="Resource" />
+      <argument index="0" name="path" type="String" />
+      <description>
 				Loads a resource from the filesystem located at [code]path[/code]. The resource is loaded on the method call (unless it's referenced already elsewhere, e.g. in another script or in the scene), which might cause slight delay, especially when loading scenes. To avoid unnecessary delays when loading something multiple times, either store the resource in a variable or use [method preload].
 				[b]Note:[/b] Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
 				[codeblock]
@@ -549,11 +548,11 @@
 				[b]Important:[/b] The path must be absolute, a local path will just return [code]null[/code].
 				This method is a simplified version of [method ResourceLoader.load], which can be used for more advanced scenarios.
 			</description>
-		</method>
-		<method name="log">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="log">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Natural logarithm. The amount of time needed to reach a certain level of continuous growth.
 				[b]Note:[/b] This is not the same as the "log" function on most calculators, which uses a base 10 logarithm.
 				[codeblock]
@@ -561,37 +560,37 @@
 				[/codeblock]
 				[b]Note:[/b] The logarithm of [code]0[/code] returns [code]-inf[/code], while negative values return [code]-nan[/code].
 			</description>
-		</method>
-		<method name="max">
-			<return type="float" />
-			<argument index="0" name="a" type="float" />
-			<argument index="1" name="b" type="float" />
-			<description>
+    </method>
+    <method name="max">
+      <return type="float" />
+      <argument index="0" name="a" type="float" />
+      <argument index="1" name="b" type="float" />
+      <description>
 				Returns the maximum of two values.
 				[codeblock]
 				max(1, 2) # Returns 2
 				max(-3.99, -4) # Returns -3.99
 				[/codeblock]
 			</description>
-		</method>
-		<method name="min">
-			<return type="float" />
-			<argument index="0" name="a" type="float" />
-			<argument index="1" name="b" type="float" />
-			<description>
+    </method>
+    <method name="min">
+      <return type="float" />
+      <argument index="0" name="a" type="float" />
+      <argument index="1" name="b" type="float" />
+      <description>
 				Returns the minimum of two values.
 				[codeblock]
 				min(1, 2) # Returns 1
 				min(-3.99, -4) # Returns -4
 				[/codeblock]
 			</description>
-		</method>
-		<method name="move_toward">
-			<return type="float" />
-			<argument index="0" name="from" type="float" />
-			<argument index="1" name="to" type="float" />
-			<argument index="2" name="delta" type="float" />
-			<description>
+    </method>
+    <method name="move_toward">
+      <return type="float" />
+      <argument index="0" name="from" type="float" />
+      <argument index="1" name="to" type="float" />
+      <argument index="2" name="delta" type="float" />
+      <description>
 				Moves [code]from[/code] toward [code]to[/code] by the [code]delta[/code] value.
 				Use a negative [code]delta[/code] value to move away.
 				[codeblock]
@@ -600,11 +599,11 @@
 				move_toward(10, 5, -1.5) # Returns 11.5
 				[/codeblock]
 			</description>
-		</method>
-		<method name="nearest_po2">
-			<return type="int" />
-			<argument index="0" name="value" type="int" />
-			<description>
+    </method>
+    <method name="nearest_po2">
+      <return type="int" />
+      <argument index="0" name="value" type="int" />
+      <description>
 				Returns the nearest equal or larger power of 2 for integer [code]value[/code].
 				In other words, returns the smallest value [code]a[/code] where [code]a = pow(2, n)[/code] such that [code]value &lt;= a[/code] for some non-negative integer [code]n[/code].
 				[codeblock]
@@ -617,11 +616,11 @@
 				[/codeblock]
 				[b]WARNING:[/b] Due to the way it is implemented, this function returns [code]0[/code] rather than [code]1[/code] for non-positive values of [code]value[/code] (in reality, 1 is the smallest integer power of 2).
 			</description>
-		</method>
-		<method name="ord">
-			<return type="int" />
-			<argument index="0" name="char" type="String" />
-			<description>
+    </method>
+    <method name="ord">
+      <return type="int" />
+      <argument index="0" name="char" type="String" />
+      <description>
 				Returns an integer representing the Unicode code point of the given Unicode character [code]char[/code].
 				[codeblock]
 				a = ord("A") # a is 65
@@ -630,11 +629,11 @@
 				[/codeblock]
 				This is the inverse of [method char].
 			</description>
-		</method>
-		<method name="parse_json">
-			<return type="Variant" />
-			<argument index="0" name="json" type="String" />
-			<description>
+    </method>
+    <method name="parse_json">
+      <return type="Variant" />
+      <argument index="0" name="json" type="String" />
+      <description>
 				Parse JSON text to a Variant. (Use [method typeof] to check if the Variant's type is what you expect.)
 				[b]Note:[/b] The JSON specification does not define integer or float types, but only a [i]number[/i] type. Therefore, parsing a JSON text will convert all numerical values to [float] types.
 				[b]Note:[/b] JSON objects do not preserve key order like Pandemonium dictionaries, thus, you should not rely on keys being in a certain order if a dictionary is constructed from JSON. In contrast, JSON arrays retain the order of their elements:
@@ -647,20 +646,20 @@
 				[/codeblock]
 				See also [JSON] for an alternative way to parse JSON text.
 			</description>
-		</method>
-		<method name="polar2cartesian">
-			<return type="Vector2" />
-			<argument index="0" name="r" type="float" />
-			<argument index="1" name="th" type="float" />
-			<description>
+    </method>
+    <method name="polar2cartesian">
+      <return type="Vector2" />
+      <argument index="0" name="r" type="float" />
+      <argument index="1" name="th" type="float" />
+      <description>
 				Converts a 2D point expressed in the polar coordinate system (a distance from the origin [code]r[/code] and an angle [code]th[/code]) to the cartesian coordinate system (X and Y axis).
 			</description>
-		</method>
-		<method name="posmod">
-			<return type="int" />
-			<argument index="0" name="a" type="int" />
-			<argument index="1" name="b" type="int" />
-			<description>
+    </method>
+    <method name="posmod">
+      <return type="int" />
+      <argument index="0" name="a" type="int" />
+      <argument index="1" name="b" type="int" />
+      <description>
 				Returns the integer modulus of [code]a/b[/code] that wraps equally in positive and negative.
 				[codeblock]
 				for i in range(-3, 4):
@@ -677,22 +676,22 @@
 				 3  0  0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="pow">
-			<return type="float" />
-			<argument index="0" name="base" type="float" />
-			<argument index="1" name="exp" type="float" />
-			<description>
+    </method>
+    <method name="pow">
+      <return type="float" />
+      <argument index="0" name="base" type="float" />
+      <argument index="1" name="exp" type="float" />
+      <description>
 				Returns the result of [code]base[/code] raised to the power of [code]exp[/code].
 				[codeblock]
 				pow(2, 5) # Returns 32.0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="preload">
-			<return type="Resource" />
-			<argument index="0" name="path" type="String" />
-			<description>
+    </method>
+    <method name="preload">
+      <return type="Resource" />
+      <argument index="0" name="path" type="String" />
+      <description>
 				Returns a [Resource] from the filesystem located at [code]path[/code]. The resource is loaded during script parsing, i.e. is loaded with the script and [method preload] effectively acts as a reference to that resource. Note that the method requires a constant path. If you want to load a resource from a dynamic/variable path, use [method load].
 				[b]Note:[/b] Resource paths can be obtained by right clicking on a resource in the Assets Panel and choosing "Copy Path" or by dragging the file from the FileSystem dock into the script.
 				[codeblock]
@@ -700,10 +699,10 @@
 				var diamond = preload("res://diamond.tscn").instance()
 				[/codeblock]
 			</description>
-		</method>
-		<method name="print" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="print" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Converts one or more arguments of any type to string in the best way possible and prints them to the console.
 				[codeblock]
 				a = [1, 2, 3]
@@ -711,35 +710,35 @@
 				[/codeblock]
 				[b]Note:[/b] Consider using [method push_error] and [method push_warning] to print error and warning messages instead of [method print]. This distinguishes them from print messages used for debugging purposes, while also displaying a stack trace when an error or warning is printed.
 			</description>
-		</method>
-		<method name="print_debug" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="print_debug" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Like [method print], but prints only when used in debug mode.
 			</description>
-		</method>
-		<method name="print_stack">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="print_stack">
+      <return type="void" />
+      <description>
 				Prints a stack track at code location, only works when running with debugger turned on.
 				Output in the console would look something like this:
 				[codeblock]
 				Frame 0 - res://test.gd:16 in function '_process'
 				[/codeblock]
 			</description>
-		</method>
-		<method name="printerr" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="printerr" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Prints one or more arguments to strings in the best way possible to standard error line.
 				[codeblock]
 				printerr("prints to stderr")
 				[/codeblock]
 			</description>
-		</method>
-		<method name="printraw" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="printraw" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Prints one or more arguments to strings in the best way possible to console. No newline is added at the end.
 				[codeblock]
 				printraw("A")
@@ -748,86 +747,86 @@
 				[/codeblock]
 				[b]Note:[/b] Due to limitations with Pandemonium's built-in console, this only prints to the terminal. If you need to print in the editor, use another method, such as [method print].
 			</description>
-		</method>
-		<method name="prints" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="prints" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Prints one or more arguments to the console with a space between each argument.
 				[codeblock]
 				prints("A", "B", "C") # Prints A B C
 				[/codeblock]
 			</description>
-		</method>
-		<method name="printt" qualifiers="vararg">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="printt" qualifiers="vararg">
+      <return type="void" />
+      <description>
 				Prints one or more arguments to the console with a tab between each argument.
 				[codeblock]
 				printt("A", "B", "C") # Prints A       B       C
 				[/codeblock]
 			</description>
-		</method>
-		<method name="push_error">
-			<return type="void" />
-			<argument index="0" name="message" type="String" />
-			<description>
+    </method>
+    <method name="push_error">
+      <return type="void" />
+      <argument index="0" name="message" type="String" />
+      <description>
 				Pushes an error message to Pandemonium's built-in debugger and to the OS terminal.
 				[codeblock]
 				push_error("test error") # Prints "test error" to debugger and terminal as error call
 				[/codeblock]
 				[b]Note:[/b] Errors printed this way will not pause project execution. To print an error message and pause project execution in debug builds, use [code]assert(false, "test error")[/code] instead.
 			</description>
-		</method>
-		<method name="push_warning">
-			<return type="void" />
-			<argument index="0" name="message" type="String" />
-			<description>
+    </method>
+    <method name="push_warning">
+      <return type="void" />
+      <argument index="0" name="message" type="String" />
+      <description>
 				Pushes a warning message to Pandemonium's built-in debugger and to the OS terminal.
 				[codeblock]
 				push_warning("test warning") # Prints "test warning" to debugger and terminal as warning call
 				[/codeblock]
 			</description>
-		</method>
-		<method name="rad2deg">
-			<return type="float" />
-			<argument index="0" name="rad" type="float" />
-			<description>
+    </method>
+    <method name="rad2deg">
+      <return type="float" />
+      <argument index="0" name="rad" type="float" />
+      <description>
 				Converts an angle expressed in radians to degrees.
 				[codeblock]
 				rad2deg(0.523599) # Returns 30.0
 				[/codeblock]
 			</description>
-		</method>
-		<method name="rand_range">
-			<return type="float" />
-			<argument index="0" name="from" type="float" />
-			<argument index="1" name="to" type="float" />
-			<description>
+    </method>
+    <method name="rand_range">
+      <return type="float" />
+      <argument index="0" name="from" type="float" />
+      <argument index="1" name="to" type="float" />
+      <description>
 				Random range, any floating point value between [code]from[/code] and [code]to[/code].
 				[codeblock]
 				prints(rand_range(0, 1), rand_range(0, 1)) # Prints e.g. 0.135591 0.405263
 				[/codeblock]
 			</description>
-		</method>
-		<method name="rand_seed">
-			<return type="Array" />
-			<argument index="0" name="seed" type="int" />
-			<description>
+    </method>
+    <method name="rand_seed">
+      <return type="Array" />
+      <argument index="0" name="seed" type="int" />
+      <description>
 				Random from seed: pass a [code]seed[/code], and an array with both number and new seed is returned. "Seed" here refers to the internal state of the pseudo random number generator. The internal state of the current implementation is 64 bits.
 			</description>
-		</method>
-		<method name="randf">
-			<return type="float" />
-			<description>
+    </method>
+    <method name="randf">
+      <return type="float" />
+      <description>
 				Returns a random floating point value on the interval [code][0, 1][/code].
 				[codeblock]
 				randf() # Returns e.g. 0.375671
 				[/codeblock]
 			</description>
-		</method>
-		<method name="randi">
-			<return type="int" />
-			<description>
+    </method>
+    <method name="randi">
+      <return type="int" />
+      <description>
 				Returns a random unsigned 32-bit integer. Use remainder to obtain a random value in the interval [code][0, N - 1][/code] (where N is smaller than 2^32).
 				[codeblock]
 				randi()           # Returns random integer between 0 and 2^32 - 1
@@ -836,20 +835,20 @@
 				randi() % 100 + 1 # Returns random integer between 1 and 100
 				[/codeblock]
 			</description>
-		</method>
-		<method name="randomize">
-			<return type="void" />
-			<description>
+    </method>
+    <method name="randomize">
+      <return type="void" />
+      <description>
 				Randomizes the seed (or the internal state) of the random number generator. Current implementation reseeds using a number based on time.
 				[codeblock]
 				func _ready():
 				    randomize()
 				[/codeblock]
 			</description>
-		</method>
-		<method name="range" qualifiers="vararg">
-			<return type="Array" />
-			<description>
+    </method>
+    <method name="range" qualifiers="vararg">
+      <return type="Array" />
+      <description>
 				Returns an array with the given range. Range can be 1 argument [code]N[/code] (0 to [code]N[/code] - 1), two arguments ([code]initial[/code], [code]final - 1[/code]) or three arguments ([code]initial[/code], [code]final - 1[/code], [code]increment[/code]). Returns an empty array if the range isn't valid (e.g. [code]range(2, 5, -1)[/code] or [code]range(5, 5, 1)[/code]).
 				Returns an array with the given range. [code]range()[/code] can have 1 argument N ([code]0[/code] to [code]N - 1[/code]), two arguments ([code]initial[/code], [code]final - 1[/code]) or three arguments ([code]initial[/code], [code]final - 1[/code], [code]increment[/code]). [code]increment[/code] can be negative. If [code]increment[/code] is negative, [code]final - 1[/code] will become [code]final + 1[/code]. Also, the initial value must be greater than the final value for the loop to run.
 				[codeblock]
@@ -878,25 +877,25 @@
 				3
 				[/codeblock]
 			</description>
-		</method>
-		<method name="range_lerp">
-			<return type="float" />
-			<argument index="0" name="value" type="float" />
-			<argument index="1" name="istart" type="float" />
-			<argument index="2" name="istop" type="float" />
-			<argument index="3" name="ostart" type="float" />
-			<argument index="4" name="ostop" type="float" />
-			<description>
+    </method>
+    <method name="range_lerp">
+      <return type="float" />
+      <argument index="0" name="value" type="float" />
+      <argument index="1" name="istart" type="float" />
+      <argument index="2" name="istop" type="float" />
+      <argument index="3" name="ostart" type="float" />
+      <argument index="4" name="ostop" type="float" />
+      <description>
 				Maps a [code]value[/code] from range [code][istart, istop][/code] to [code][ostart, ostop][/code].
 				[codeblock]
 				range_lerp(75, 0, 100, -1, 1) # Returns 0.5
 				[/codeblock]
 			</description>
-		</method>
-		<method name="round">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="round">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Rounds [code]s[/code] to the nearest whole number, with halfway cases rounded away from zero.
 				[codeblock]
 				a = round(2.49) # a is 2.0
@@ -905,22 +904,22 @@
 				[/codeblock]
 				See also [method floor], [method ceil], [method stepify], and [int].
 			</description>
-		</method>
-		<method name="seed">
-			<return type="void" />
-			<argument index="0" name="seed" type="int" />
-			<description>
+    </method>
+    <method name="seed">
+      <return type="void" />
+      <argument index="0" name="seed" type="int" />
+      <description>
 				Sets seed for the random number generator.
 				[codeblock]
 				my_seed = "Pandemonium Rocks"
 				seed(my_seed.hash())
 				[/codeblock]
 			</description>
-		</method>
-		<method name="sign">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="sign">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the sign of [code]s[/code]: -1 or 1. Returns 0 if [code]s[/code] is 0.
 				[codeblock]
 				sign(-6) # Returns -1
@@ -928,34 +927,34 @@
 				sign(6)  # Returns 1
 				[/codeblock]
 			</description>
-		</method>
-		<method name="sin">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="sin">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the sine of angle [code]s[/code] in radians.
 				[codeblock]
 				sin(0.523599) # Returns 0.5
 				[/codeblock]
 			</description>
-		</method>
-		<method name="sinh">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="sinh">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the hyperbolic sine of [code]s[/code].
 				[codeblock]
 				a = log(2.0) # Returns 0.693147
 				sinh(a) # Returns 0.75
 				[/codeblock]
 			</description>
-		</method>
-		<method name="smoothstep">
-			<return type="float" />
-			<argument index="0" name="from" type="float" />
-			<argument index="1" name="to" type="float" />
-			<argument index="2" name="s" type="float" />
-			<description>
+    </method>
+    <method name="smoothstep">
+      <return type="float" />
+      <argument index="0" name="from" type="float" />
+      <argument index="1" name="to" type="float" />
+      <argument index="2" name="s" type="float" />
+      <description>
 				Returns the result of smoothly interpolating the value of [code]s[/code] between [code]0[/code] and [code]1[/code], based on the where [code]s[/code] lies with respect to the edges [code]from[/code] and [code]to[/code].
 				The return value is [code]0[/code] if [code]s &lt;= from[/code], and [code]1[/code] if [code]s &gt;= to[/code]. If [code]s[/code] lies between [code]from[/code] and [code]to[/code], the returned value follows an S-shaped curve that maps [code]s[/code] between [code]0[/code] and [code]1[/code].
 				This S-shaped curve is the cubic Hermite interpolator, given by [code]f(y) = 3*y^2 - 2*y^3[/code] where [code]y = (x-from) / (to-from)[/code].
@@ -968,22 +967,22 @@
 				Compared to [method ease] with a curve value of [code]-1.6521[/code], [method smoothstep] returns the smoothest possible curve with no sudden changes in the derivative. If you need to perform more advanced transitions, use [Tween] or [AnimationPlayer].
 				[url=https://raw.githubusercontent.com/godotengine/godot-docs/3.4/img/smoothstep_ease_comparison.png]Comparison between smoothstep() and ease(x, -1.6521) return values[/url]
 			</description>
-		</method>
-		<method name="sqrt">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="sqrt">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the square root of [code]s[/code], where [code]s[/code] is a non-negative number.
 				[codeblock]
 				sqrt(9) # Returns 3
 				[/codeblock]
 				[b]Note:[/b] Negative values of [code]s[/code] return NaN. If you need negative inputs, use [code]System.Numerics.Complex[/code] in C#.
 			</description>
-		</method>
-		<method name="step_decimals">
-			<return type="int" />
-			<argument index="0" name="step" type="float" />
-			<description>
+    </method>
+    <method name="step_decimals">
+      <return type="int" />
+      <argument index="0" name="step" type="float" />
+      <description>
 				Returns the position of the first non-zero digit, after the decimal point. Note that the maximum return value is 10, which is a design decision in the implementation.
 				[codeblock]
 				n = step_decimals(5)           # n is 0
@@ -991,12 +990,12 @@
 				n = step_decimals(0.000000005) # n is 9
 				[/codeblock]
 			</description>
-		</method>
-		<method name="stepify">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<argument index="1" name="step" type="float" />
-			<description>
+    </method>
+    <method name="stepify">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <argument index="1" name="step" type="float" />
+      <description>
 				Snaps float value [code]s[/code] to a given [code]step[/code]. This can also be used to round a floating point number to an arbitrary number of decimals.
 				[codeblock]
 				stepify(100, 32) # Returns 96.0
@@ -1004,10 +1003,10 @@
 				[/codeblock]
 				See also [method ceil], [method floor], [method round], and [int].
 			</description>
-		</method>
-		<method name="str" qualifiers="vararg">
-			<return type="String" />
-			<description>
+    </method>
+    <method name="str" qualifiers="vararg">
+      <return type="String" />
+      <description>
 				Converts one or more arguments of any type to string in the best way possible.
 				[codeblock]
 				var a = [10, 20, 30]
@@ -1016,11 +1015,11 @@
 				len(b) # Returns 12
 				[/codeblock]
 			</description>
-		</method>
-		<method name="str2var">
-			<return type="Variant" />
-			<argument index="0" name="string" type="String" />
-			<description>
+    </method>
+    <method name="str2var">
+      <return type="Variant" />
+      <argument index="0" name="string" type="String" />
+      <description>
 				Converts a formatted string that was returned by [method var2str] to the original value.
 				[codeblock]
 				a = '{ "a": 1, "b": 2 }'
@@ -1028,32 +1027,32 @@
 				print(b["a"]) # Prints 1
 				[/codeblock]
 			</description>
-		</method>
-		<method name="tan">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="tan">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the tangent of angle [code]s[/code] in radians.
 				[codeblock]
 				tan(deg2rad(45)) # Returns 1
 				[/codeblock]
 			</description>
-		</method>
-		<method name="tanh">
-			<return type="float" />
-			<argument index="0" name="s" type="float" />
-			<description>
+    </method>
+    <method name="tanh">
+      <return type="float" />
+      <argument index="0" name="s" type="float" />
+      <description>
 				Returns the hyperbolic tangent of [code]s[/code].
 				[codeblock]
 				a = log(2.0) # a is 0.693147
 				b = tanh(a)  # b is 0.6
 				[/codeblock]
 			</description>
-		</method>
-		<method name="to_json">
-			<return type="String" />
-			<argument index="0" name="var" type="Variant" />
-			<description>
+    </method>
+    <method name="to_json">
+      <return type="String" />
+      <argument index="0" name="var" type="Variant" />
+      <description>
 				Converts a [Variant] [code]var[/code] to JSON text and return the result. Useful for serializing data to store or send over the network.
 				[codeblock]
 				# Both numbers below are integers.
@@ -1065,22 +1064,22 @@
 				[b]Note:[/b] The JSON specification does not define integer or float types, but only a [i]number[/i] type. Therefore, converting a [Variant] to JSON text will convert all numerical values to [float] types.
 				See also [JSON] for an alternative way to convert a [Variant] to JSON text.
 			</description>
-		</method>
-		<method name="type_exists">
-			<return type="bool" />
-			<argument index="0" name="type" type="String" />
-			<description>
+    </method>
+    <method name="type_exists">
+      <return type="bool" />
+      <argument index="0" name="type" type="String" />
+      <description>
 				Returns whether the given class exists in [ClassDB].
 				[codeblock]
 				type_exists("Sprite") # Returns true
 				type_exists("Variant") # Returns false
 				[/codeblock]
 			</description>
-		</method>
-		<method name="typeof">
-			<return type="int" />
-			<argument index="0" name="what" type="Variant" />
-			<description>
+    </method>
+    <method name="typeof">
+      <return type="int" />
+      <argument index="0" name="what" type="Variant" />
+      <description>
 				Returns the internal type of the given Variant object, using the [enum Variant.Type] values.
 				[codeblock]
 				p = parse_json('["a", "b", "c"]')
@@ -1090,11 +1089,11 @@
 				    print("unexpected results")
 				[/codeblock]
 			</description>
-		</method>
-		<method name="validate_json">
-			<return type="String" />
-			<argument index="0" name="json" type="String" />
-			<description>
+    </method>
+    <method name="validate_json">
+      <return type="String" />
+      <argument index="0" name="json" type="String" />
+      <description>
 				Checks that [code]json[/code] is valid JSON data. Returns an empty string if valid, or an error message otherwise.
 				[codeblock]
 				j = to_json([1, 2, 3])
@@ -1105,19 +1104,19 @@
 				    push_error("Invalid JSON: " + v)
 				[/codeblock]
 			</description>
-		</method>
-		<method name="var2bytes">
-			<return type="PoolByteArray" />
-			<argument index="0" name="var" type="Variant" />
-			<argument index="1" name="full_objects" type="bool" default="false" />
-			<description>
+    </method>
+    <method name="var2bytes">
+      <return type="PoolByteArray" />
+      <argument index="0" name="var" type="Variant" />
+      <argument index="1" name="full_objects" type="bool" default="false" />
+      <description>
 				Encodes a variable value to a byte array. When [code]full_objects[/code] is [code]true[/code] encoding objects is allowed (and can potentially include code).
 			</description>
-		</method>
-		<method name="var2str">
-			<return type="String" />
-			<argument index="0" name="var" type="Variant" />
-			<description>
+    </method>
+    <method name="var2str">
+      <return type="String" />
+      <argument index="0" name="var" type="Variant" />
+      <description>
 				Converts a Variant [code]var[/code] to a formatted string that can later be parsed using [method str2var].
 				[codeblock]
 				a = { "a": 1, "b": 2 }
@@ -1131,21 +1130,21 @@
 				}
 				[/codeblock]
 			</description>
-		</method>
-		<method name="weakref">
-			<return type="WeakRef" />
-			<argument index="0" name="obj" type="Object" />
-			<description>
+    </method>
+    <method name="weakref">
+      <return type="WeakRef" />
+      <argument index="0" name="obj" type="Object" />
+      <description>
 				Returns a weak reference to an object.
 				A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it.
 			</description>
-		</method>
-		<method name="wrapf">
-			<return type="float" />
-			<argument index="0" name="value" type="float" />
-			<argument index="1" name="min" type="float" />
-			<argument index="2" name="max" type="float" />
-			<description>
+    </method>
+    <method name="wrapf">
+      <return type="float" />
+      <argument index="0" name="value" type="float" />
+      <argument index="1" name="min" type="float" />
+      <argument index="2" name="max" type="float" />
+      <description>
 				Wraps float [code]value[/code] between [code]min[/code] and [code]max[/code].
 				Usable for creating loop-alike behavior or infinite surfaces.
 				[codeblock]
@@ -1163,13 +1162,13 @@
 				[b]Note:[/b] If [code]min[/code] is [code]0[/code], this is equivalent to [method fposmod], so prefer using that instead.
 				[code]wrapf[/code] is more flexible than using the [method fposmod] approach by giving the user control over the minimum value.
 			</description>
-		</method>
-		<method name="wrapi">
-			<return type="int" />
-			<argument index="0" name="value" type="int" />
-			<argument index="1" name="min" type="int" />
-			<argument index="2" name="max" type="int" />
-			<description>
+    </method>
+    <method name="wrapi">
+      <return type="int" />
+      <argument index="0" name="value" type="int" />
+      <argument index="1" name="min" type="int" />
+      <argument index="2" name="max" type="int" />
+      <description>
 				Wraps integer [code]value[/code] between [code]min[/code] and [code]max[/code].
 				Usable for creating loop-alike behavior or infinite surfaces.
 				[codeblock]
@@ -1183,14 +1182,14 @@
 				[b]Note:[/b] If [code]min[/code] is [code]0[/code], this is equivalent to [method posmod], so prefer using that instead.
 				[code]wrapi[/code] is more flexible than using the [method posmod] approach by giving the user control over the minimum value.
 			</description>
-		</method>
-		<method name="yield">
-			<return type="GDScriptFunctionState" />
-			<argument index="0" name="object" type="Object" default="null" />
-			<argument index="1" name="signal" type="String" default="&quot;&quot;" />
-			<description>
+    </method>
+    <method name="yield">
+      <return type="CScriptFunctionState" />
+      <argument index="0" name="object" type="Object" default="null" />
+      <argument index="1" name="signal" type="String" default="&quot;&quot;" />
+      <description>
 				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.
 				You can also use [code]yield[/code] to wait for a function to finish:
 				[codeblock]
@@ -1199,7 +1198,7 @@
 				    print('Ready')
 
 				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)
 				    yield(get_tree().create_timer(1.0), "timeout")
 				    print(2)
@@ -1214,24 +1213,24 @@
 				# Ready
 				[/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.
-				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>
-		</method>
-	</methods>
-	<constants>
-		<constant name="PI" value="3.141593">
+    </method>
+  </methods>
+  <constants>
+    <constant name="PI" value="3.141593">
 			Constant that represents how many times the diameter of a circle fits around its perimeter. This is equivalent to [code]TAU / 2[/code].
 		</constant>
-		<constant name="TAU" value="6.283185">
+    <constant name="TAU" value="6.283185">
 			The circle constant, the circumference of the unit circle in radians. This is equivalent to [code]PI * 2[/code], or 360 degrees in rotations.
 		</constant>
-		<constant name="INF" value="inf">
+    <constant name="INF" value="inf">
 			Positive floating-point infinity. This is the result of floating-point division when the divisor is [code]0.0[/code]. For negative infinity, use [code]-INF[/code]. Dividing by [code]-0.0[/code] will result in negative infinity if the numerator is positive, so dividing by [code]0.0[/code] is not the same as dividing by [code]-0.0[/code] (despite [code]0.0 == -0.0[/code] returning [code]true[/code]).
 			[b]Note:[/b] Numeric infinity is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer number by [code]0[/code] will not result in [constant INF] and will result in a run-time error instead.
 		</constant>
-		<constant name="NAN" value="nan">
+    <constant name="NAN" value="nan">
 			"Not a Number", an invalid floating-point value. [constant NAN] has special properties, including that it is not equal to itself ([code]NAN == NAN[/code] returns [code]false[/code]). It is output by some invalid operations, such as dividing floating-point [code]0.0[/code] by [code]0.0[/code].
 			[b]Note:[/b] "Not a Number" is only a concept with floating-point numbers, and has no equivalent for integers. Dividing an integer [code]0[/code] by [code]0[/code] will not result in [constant NAN] and will result in a run-time error instead.
 		</constant>
-	</constants>
+  </constants>
 </class>
diff --git a/modules/cscript/doc_classes/CScript.xml b/modules/cscript/doc_classes/CScript.xml
index fdfd2ee7e..43555725b 100644
--- a/modules/cscript/doc_classes/CScript.xml
+++ b/modules/cscript/doc_classes/CScript.xml
@@ -1,25 +1,25 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-<class name="GDScript" inherits="Script" version="3.5">
-	<brief_description>
-		A script implemented in the GDScript programming language.
+<?xml version="1.0" encoding="UTF-8"?>
+<class name="CScript" inherits="Script" version="3.5">
+  <brief_description>
+		A script implemented in the CScript programming language.
 	</brief_description>
-	<description>
-		A script implemented in the GDScript programming language. The script extends the functionality of all objects that instance it.
+  <description>
+		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.
 	</description>
-	<tutorials>
-		<link>$DOCS_URL/tutorials/scripting/gdscript/index.html</link>
-	</tutorials>
-	<methods>
-		<method name="get_as_byte_code" qualifiers="const">
-			<return type="PoolByteArray" />
-			<description>
+  <tutorials>
+    <link>$DOCS_URL/tutorials/scripting/gdscript/index.html</link>
+  </tutorials>
+  <methods>
+    <method name="get_as_byte_code" qualifiers="const">
+      <return type="PoolByteArray" />
+      <description>
 				Returns byte code for the script source code.
 			</description>
-		</method>
-		<method name="new" qualifiers="vararg">
-			<return type="Variant" />
-			<description>
+    </method>
+    <method name="new" qualifiers="vararg">
+      <return type="Variant" />
+      <description>
 				Returns a new instance of the script.
 				For example:
 				[codeblock]
@@ -28,8 +28,7 @@
 				assert(instance.get_script() == MyClass)
 				[/codeblock]
 			</description>
-		</method>
-	</methods>
-	<constants>
-	</constants>
+    </method>
+  </methods>
+  <constants></constants>
 </class>
diff --git a/modules/cscript/editor/cscript_highlighter.cpp b/modules/cscript/editor/cscript_highlighter.cpp
index 020c8c009..5a06a9dfb 100644
--- a/modules/cscript/editor/cscript_highlighter.cpp
+++ b/modules/cscript/editor/cscript_highlighter.cpp
@@ -28,8 +28,8 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "gdscript_highlighter.h"
-#include "../gdscript_tokenizer.h"
+#include "cscript_highlighter.h"
+#include "../cscript_tokenizer.h"
 #include "editor/editor_settings.h"
 #include "scene/gui/text_edit.h"
 
@@ -57,7 +57,7 @@ static bool _is_bin_symbol(CharType c) {
 	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;
 
 	Type next_type = NONE;
@@ -219,7 +219,7 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
 
 			if (str[k] == '(') {
 				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;
 			}
 		}
@@ -291,7 +291,7 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
 		} else if (in_function_name) {
 			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;
 			} else {
 				color = function_color;
@@ -344,17 +344,17 @@ Map<int, TextEdit::HighlighterInfo> GDScriptSyntaxHighlighter::_get_line_syntax_
 	return color_map;
 }
 
-String GDScriptSyntaxHighlighter::get_name() const {
-	return "GDScript";
+String CScriptSyntaxHighlighter::get_name() const {
+	return "CScript";
 }
 
-List<String> GDScriptSyntaxHighlighter::get_supported_languages() {
+List<String> CScriptSyntaxHighlighter::get_supported_languages() {
 	List<String> languages;
-	languages.push_back("GDScript");
+	languages.push_back("CScript");
 	return languages;
 }
 
-void GDScriptSyntaxHighlighter::_update_cache() {
+void CScriptSyntaxHighlighter::_update_cache() {
 	font_color = text_editor->get_color("font_color");
 	symbol_color = text_editor->get_color("symbol_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");
 }
 
-SyntaxHighlighter *GDScriptSyntaxHighlighter::create() {
-	return memnew(GDScriptSyntaxHighlighter);
+SyntaxHighlighter *CScriptSyntaxHighlighter::create() {
+	return memnew(CScriptSyntaxHighlighter);
 }
diff --git a/modules/cscript/editor/cscript_highlighter.h b/modules/cscript/editor/cscript_highlighter.h
index d4deef767..3a2b13ea5 100644
--- a/modules/cscript/editor/cscript_highlighter.h
+++ b/modules/cscript/editor/cscript_highlighter.h
@@ -32,7 +32,7 @@
 
 #include "scene/gui/text_edit.h"
 
-class GDScriptSyntaxHighlighter : public SyntaxHighlighter {
+class CScriptSyntaxHighlighter : public SyntaxHighlighter {
 private:
 	enum Type {
 		NONE,
@@ -68,4 +68,4 @@ public:
 	virtual List<String> get_supported_languages();
 };
 
-#endif // GDSCRIPT_HIGHLIGHTER_H
+#endif // CSCRIPT_HIGHLIGHTER_H
diff --git a/modules/cscript/register_types.cpp b/modules/cscript/register_types.cpp
index 3b1dba4fd..8d2f66239 100644
--- a/modules/cscript/register_types.cpp
+++ b/modules/cscript/register_types.cpp
@@ -37,19 +37,19 @@
 #include "cscript.h"
 #include "cscript_tokenizer.h"
 
-GDScriptLanguage *script_language_gd = nullptr;
-Ref<ResourceFormatLoaderGDScript> resource_loader_gd;
-Ref<ResourceFormatSaverGDScript> resource_saver_gd;
+CScriptLanguage *script_language_cscript = nullptr;
+Ref<ResourceFormatLoaderCScript> resource_loader_cscript;
+Ref<ResourceFormatSaverCScript> resource_saver_cscript;
 
 #ifdef TOOLS_ENABLED
 
+#include "editor/cscript_highlighter.h"
 #include "editor/editor_export.h"
 #include "editor/editor_node.h"
 #include "editor/editor_settings.h"
-#include "editor/gdscript_highlighter.h"
 
-class EditorExportGDScript : public EditorExportPlugin {
-	GDCLASS(EditorExportGDScript, EditorExportPlugin);
+class EditorExportCScript : public EditorExportPlugin {
+	GDCLASS(EditorExportCScript, EditorExportPlugin);
 
 public:
 	virtual void _export_file(const String &p_path, const String &p_type, const Set<String> &p_features) {
@@ -74,7 +74,7 @@ public:
 
 		String txt;
 		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 (script_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) {
@@ -129,42 +129,42 @@ public:
 };
 
 static void _editor_init() {
-	Ref<EditorExportGDScript> gd_export;
+	Ref<EditorExportCScript> gd_export;
 	gd_export.instance();
 	EditorExport::get_singleton()->add_export_plugin(gd_export);
 }
 
 #endif // TOOLS_ENABLED
 
-void register_gdscript_types() {
-	ClassDB::register_class<GDScript>();
-	ClassDB::register_virtual_class<GDScriptFunctionState>();
+void register_cscript_types() {
+	ClassDB::register_class<CScript>();
+	ClassDB::register_virtual_class<CScriptFunctionState>();
 
-	script_language_gd = memnew(GDScriptLanguage);
-	ScriptServer::register_language(script_language_gd);
+	script_language_cscript = memnew(CScriptLanguage);
+	ScriptServer::register_language(script_language_cscript);
 
-	resource_loader_gd.instance();
-	ResourceLoader::add_resource_format_loader(resource_loader_gd);
+	resource_loader_cscript.instance();
+	ResourceLoader::add_resource_format_loader(resource_loader_cscript);
 
-	resource_saver_gd.instance();
-	ResourceSaver::add_resource_format_saver(resource_saver_gd);
+	resource_saver_cscript.instance();
+	ResourceSaver::add_resource_format_saver(resource_saver_cscript);
 
 #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);
 #endif // TOOLS_ENABLED
 }
 
-void unregister_gdscript_types() {
-	ScriptServer::unregister_language(script_language_gd);
+void unregister_cscript_types() {
+	ScriptServer::unregister_language(script_language_cscript);
 
-	if (script_language_gd) {
-		memdelete(script_language_gd);
+	if (script_language_cscript) {
+		memdelete(script_language_cscript);
 	}
 
-	ResourceLoader::remove_resource_format_loader(resource_loader_gd);
-	resource_loader_gd.unref();
+	ResourceLoader::remove_resource_format_loader(resource_loader_cscript);
+	resource_loader_cscript.unref();
 
-	ResourceSaver::remove_resource_format_saver(resource_saver_gd);
-	resource_saver_gd.unref();
+	ResourceSaver::remove_resource_format_saver(resource_saver_cscript);
+	resource_saver_cscript.unref();
 }
diff --git a/modules/cscript/register_types.h b/modules/cscript/register_types.h
index 85c806afd..bf6033074 100644
--- a/modules/cscript/register_types.h
+++ b/modules/cscript/register_types.h
@@ -33,4 +33,4 @@
 void register_cscript_types();
 void unregister_cscript_types();
 
-#endif // GDSCRIPT_REGISTER_TYPES_H
+#endif // CSCRIPT_REGISTER_TYPES_H