renamed dlscript module to gdnative

1 files changed, 205 insertions, 208 deletions

diff --git a/modules/dlscript/dl_script.cpp b/modules/gdnative/gdnative.cpp
index fa082d7b9..43b309ae3 100644
--- a/modules/dlscript/dl_script.cpp
+++ b/modules/gdnative/gdnative.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  dl_script.cpp                                                        */
+/*  gdnative.cpp                                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -27,7 +27,7 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#include "dl_script.h"
+#include "gdnative.h"
 
 #include "global_config.h"
 #include "global_constants.h"
@@ -48,8 +48,8 @@
 
 Error NativeLibrary::initialize(NativeLibrary *&p_native_lib, const StringName p_path) {
 
-	if (DLScriptLanguage::get_singleton()->initialized_libraries.has(p_path)) {
-		p_native_lib = DLScriptLanguage::get_singleton()->initialized_libraries[p_path];
+	if (GDNativeScriptLanguage::get_singleton()->initialized_libraries.has(p_path)) {
+		p_native_lib = GDNativeScriptLanguage::get_singleton()->initialized_libraries[p_path];
 		return OK;
 	}
 
@@ -68,13 +68,13 @@ Error NativeLibrary::initialize(NativeLibrary *&p_native_lib, const StringName p
 	// Get the method
 
 	void *library_init;
-	error = OS::get_singleton()->get_dynamic_library_symbol_handle(lib->handle, DLScriptLanguage::get_init_symbol_name(), library_init);
+	error = OS::get_singleton()->get_dynamic_library_symbol_handle(lib->handle, GDNativeScriptLanguage::get_init_symbol_name(), library_init);
 	if (error) return error;
 	ERR_FAIL_COND_V(!library_init, ERR_BUG);
 
-	void (*library_init_fpointer)(godot_dlscript_init_options *) = (void (*)(godot_dlscript_init_options *))library_init;
+	void (*library_init_fpointer)(godot_native_init_options *) = (void (*)(godot_native_init_options *))library_init;
 
-	godot_dlscript_init_options options;
+	godot_native_init_options options;
 
 	options.in_editor = SceneTree::get_singleton()->is_editor_hint();
 	/*
@@ -85,14 +85,14 @@ Error NativeLibrary::initialize(NativeLibrary *&p_native_lib, const StringName p
 
 	library_init_fpointer(&options); // Catch errors?
 
-	DLScriptLanguage::get_singleton()->initialized_libraries[p_path] = lib;
+	GDNativeScriptLanguage::get_singleton()->initialized_libraries[p_path] = lib;
 
 	return OK;
 }
 
 Error NativeLibrary::terminate(NativeLibrary *&p_native_lib) {
 
-	if (!DLScriptLanguage::get_singleton()->initialized_libraries.has(p_native_lib->path)) {
+	if (!GDNativeScriptLanguage::get_singleton()->initialized_libraries.has(p_native_lib->path)) {
 		OS::get_singleton()->close_dynamic_library(p_native_lib->handle);
 		p_native_lib->handle = 0;
 		return OK;
@@ -100,18 +100,18 @@ Error NativeLibrary::terminate(NativeLibrary *&p_native_lib) {
 
 	Error error = OK;
 	void *library_terminate;
-	error = OS::get_singleton()->get_dynamic_library_symbol_handle(p_native_lib->handle, DLScriptLanguage::get_terminate_symbol_name(), library_terminate);
+	error = OS::get_singleton()->get_dynamic_library_symbol_handle(p_native_lib->handle, GDNativeScriptLanguage::get_terminate_symbol_name(), library_terminate);
 	if (error)
 		return OK; // no terminate? okay, not that important lol
 
-	void (*library_terminate_pointer)(godot_dlscript_terminate_options *) = (void (*)(godot_dlscript_terminate_options *))library_terminate;
+	void (*library_terminate_pointer)(godot_native_terminate_options *) = (void (*)(godot_native_terminate_options *))library_terminate;
 
-	godot_dlscript_terminate_options options;
+	godot_native_terminate_options options;
 	options.in_editor = SceneTree::get_singleton()->is_editor_hint();
 
 	library_terminate_pointer(&options);
 
-	DLScriptLanguage::get_singleton()->initialized_libraries.erase(p_native_lib->path);
+	GDNativeScriptLanguage::get_singleton()->initialized_libraries.erase(p_native_lib->path);
 
 	OS::get_singleton()->close_dynamic_library(p_native_lib->handle);
 	p_native_lib->handle = 0;
@@ -122,12 +122,13 @@ Error NativeLibrary::terminate(NativeLibrary *&p_native_lib) {
 // Script
 #ifdef TOOLS_ENABLED
 
-void DLScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
+void GDNativeScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
+	ERR_FAIL_COND(!script_data);
 
 	List<PropertyInfo> pinfo;
 	Map<StringName, Variant> values;
 
-	for (Map<StringName, DLScriptData::Property>::Element *E = script_data->properties.front(); E; E = E->next()) {
+	for (Map<StringName, GDNativeScriptData::Property>::Element *E = script_data->properties.front(); E; E = E->next()) {
 		PropertyInfo p = E->get().info;
 		p.name = String(E->key());
 		pinfo.push_back(p);
@@ -137,24 +138,24 @@ void DLScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder) {
 	p_placeholder->update(pinfo, values);
 }
 
-void DLScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
+void GDNativeScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
 
 	placeholders.erase(p_placeholder);
 }
 
 #endif
 
-bool DLScript::can_instance() const {
-#ifdef DLSCRIPT_EDITOR_FEATURES
+bool GDNativeScript::can_instance() const {
+#ifdef TOOLS_ENABLED
 	return script_data || (!is_tool() && !ScriptServer::is_scripting_enabled());
 #else
 	// allow defaultlibrary without editor features
 	if (!library.is_valid()) {
-		String path = GLOBAL_GET("dlscript/default_dllibrary");
+		String path = GLOBAL_GET("gdnative/default_gdnativelibrary");
 
 		RES lib = ResourceLoader::load(path);
 
-		if (lib.is_valid() && lib->cast_to<DLLibrary>()) {
+		if (lib.is_valid() && lib->cast_to<GDNativeLibrary>()) {
 			return true;
 		}
 	}
@@ -165,28 +166,27 @@ bool DLScript::can_instance() const {
 	// change to true enable in editor stuff.
 }
 
-Ref<Script> DLScript::get_base_script() const {
-	Ref<DLScript> base_script;
+Ref<Script> GDNativeScript::get_base_script() const {
+	Ref<GDNativeScript> base_script;
 	base_script->library = library;
 	base_script->script_data = script_data;
 	base_script->script_name = script_data->base;
 	return base_script;
 }
 
-StringName DLScript::get_instance_base_type() const {
+StringName GDNativeScript::get_instance_base_type() const {
 	return script_data->base_native_type;
 }
 
-ScriptInstance *DLScript::instance_create(Object *p_this) {
+ScriptInstance *GDNativeScript::instance_create(Object *p_this) {
 
 #ifdef TOOLS_ENABLED
 
-// find a good way to initialize stuff in the editor
-#ifdef DLSCRIPT_EDITOR_FEATURES
+	// find a good way to initialize stuff in the editor
 	if (!ScriptServer::is_scripting_enabled() && !is_tool()) {
 		// placeholder, for nodes. But for tools we want the real thing
 
-		PlaceHolderScriptInstance *sins = memnew(PlaceHolderScriptInstance(DLScriptLanguage::singleton, Ref<Script>((Script *)this), p_this));
+		PlaceHolderScriptInstance *sins = memnew(PlaceHolderScriptInstance(GDNativeScriptLanguage::singleton, Ref<Script>((Script *)this), p_this));
 		placeholders.insert(sins);
 
 		if (!library.is_valid())
@@ -210,26 +210,25 @@ ScriptInstance *DLScript::instance_create(Object *p_this) {
 
 		return sins;
 	}
-#endif
 
 #endif
 
 	if (!library.is_valid()) {
-		String path = GLOBAL_GET("dlscript/default_dllibrary");
+		String path = GLOBAL_GET("gdnative/default_gdnativelibrary");
 
 		RES lib = ResourceLoader::load(path);
 
-		if (lib.is_valid() && lib->cast_to<DLLibrary>()) {
+		if (lib.is_valid() && lib->cast_to<GDNativeLibrary>()) {
 			set_library(lib);
 		}
 	}
 
-	DLInstance *new_instance = memnew(DLInstance);
+	GDNativeInstance *new_instance = memnew(GDNativeInstance);
 
 	new_instance->owner = p_this;
-	new_instance->script = Ref<DLScript>(this);
+	new_instance->script = Ref<GDNativeScript>(this);
 
-#ifndef DLSCRIPT_EDITOR_FEATURES
+#ifndef TOOLS_ENABLED
 	if (!ScriptServer::is_scripting_enabled()) {
 		new_instance->userdata = 0;
 	} else {
@@ -243,26 +242,26 @@ ScriptInstance *DLScript::instance_create(Object *p_this) {
 	return new_instance;
 }
 
-bool DLScript::instance_has(const Object *p_this) const {
+bool GDNativeScript::instance_has(const Object *p_this) const {
 	return instances.has((Object *)p_this); // TODO
 }
 
-bool DLScript::has_source_code() const {
+bool GDNativeScript::has_source_code() const {
 	return false;
 }
 
-String DLScript::get_source_code() const {
+String GDNativeScript::get_source_code() const {
 	return "";
 }
 
-Error DLScript::reload(bool p_keep_state) {
+Error GDNativeScript::reload(bool p_keep_state) {
 	return FAILED;
 }
 
-bool DLScript::has_method(const StringName &p_method) const {
+bool GDNativeScript::has_method(const StringName &p_method) const {
 	if (!script_data)
 		return false;
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
 		if (data->methods.has(p_method))
@@ -274,10 +273,10 @@ bool DLScript::has_method(const StringName &p_method) const {
 	return false;
 }
 
-MethodInfo DLScript::get_method_info(const StringName &p_method) const {
+MethodInfo GDNativeScript::get_method_info(const StringName &p_method) const {
 	if (!script_data)
 		return MethodInfo();
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
 		if (data->methods.has(p_method))
@@ -290,14 +289,14 @@ MethodInfo DLScript::get_method_info(const StringName &p_method) const {
 	return MethodInfo();
 }
 
-void DLScript::get_script_method_list(List<MethodInfo> *p_list) const {
+void GDNativeScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	if (!script_data) return;
 
 	Set<MethodInfo> methods;
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
-		for (Map<StringName, DLScriptData::Method>::Element *E = data->methods.front(); E; E = E->next()) {
+		for (Map<StringName, GDNativeScriptData::Method>::Element *E = data->methods.front(); E; E = E->next()) {
 			methods.insert(E->get().info);
 		}
 		data = data->base_data;
@@ -308,14 +307,14 @@ void DLScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	}
 }
 
-void DLScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+void GDNativeScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	if (!script_data) return;
 
 	Set<PropertyInfo> properties;
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
-		for (Map<StringName, DLScriptData::Property>::Element *E = data->properties.front(); E; E = E->next()) {
+		for (Map<StringName, GDNativeScriptData::Property>::Element *E = data->properties.front(); E; E = E->next()) {
 			properties.insert(E->get().info);
 		}
 		data = data->base_data;
@@ -326,10 +325,10 @@ void DLScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	}
 }
 
-bool DLScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
+bool GDNativeScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
 	if (!script_data) return false;
 
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
 		if (data->properties.has(p_property)) {
@@ -343,24 +342,24 @@ bool DLScript::get_property_default_value(const StringName &p_property, Variant
 	return false;
 }
 
-bool DLScript::is_tool() const {
+bool GDNativeScript::is_tool() const {
 	ERR_FAIL_COND_V(!script_data, false);
 	return script_data->is_tool;
 }
 
-String DLScript::get_node_type() const {
+String GDNativeScript::get_node_type() const {
 	return ""; // ?
 }
 
-ScriptLanguage *DLScript::get_language() const {
-	return DLScriptLanguage::singleton;
+ScriptLanguage *GDNativeScript::get_language() const {
+	return GDNativeScriptLanguage::singleton;
 }
 
-bool DLScript::has_script_signal(const StringName &p_signal) const {
+bool GDNativeScript::has_script_signal(const StringName &p_signal) const {
 	if (!script_data)
 		return false;
 
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
 		if (data->signals_.has(p_signal)) {
@@ -373,16 +372,16 @@ bool DLScript::has_script_signal(const StringName &p_signal) const {
 	return false;
 }
 
-void DLScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
+void GDNativeScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 	if (!script_data)
 		return;
 
 	Set<MethodInfo> signals_;
-	DLScriptData *data = script_data;
+	GDNativeScriptData *data = script_data;
 
 	while (data) {
 
-		for (Map<StringName, DLScriptData::Signal>::Element *S = data->signals_.front(); S; S = S->next()) {
+		for (Map<StringName, GDNativeScriptData::Signal>::Element *S = data->signals_.front(); S; S = S->next()) {
 			signals_.insert(S->get().signal);
 		}
 
@@ -394,11 +393,11 @@ void DLScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 	}
 }
 
-Ref<DLLibrary> DLScript::get_library() const {
+Ref<GDNativeLibrary> GDNativeScript::get_library() const {
 	return library;
 }
 
-void DLScript::set_library(Ref<DLLibrary> p_library) {
+void GDNativeScript::set_library(Ref<GDNativeLibrary> p_library) {
 	library = p_library;
 
 #ifdef TOOLS_ENABLED
@@ -415,15 +414,15 @@ void DLScript::set_library(Ref<DLLibrary> p_library) {
 	}
 }
 
-StringName DLScript::get_script_name() const {
+StringName GDNativeScript::get_script_name() const {
 	return script_name;
 }
 
-void DLScript::set_script_name(StringName p_script_name) {
+void GDNativeScript::set_script_name(StringName p_script_name) {
 	script_name = p_script_name;
 
 	if (library.is_valid()) {
-#ifdef DLSCRIPT_EDITOR_FEATURES
+#ifdef TOOLS_ENABLED
 		if (!library->native_library) {
 			library->_initialize();
 		}
@@ -435,31 +434,31 @@ void DLScript::set_script_name(StringName p_script_name) {
 	}
 }
 
-void DLScript::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("get_library"), &DLScript::get_library);
-	ClassDB::bind_method(D_METHOD("set_library", "library"), &DLScript::set_library);
-	ClassDB::bind_method(D_METHOD("get_script_name"), &DLScript::get_script_name);
-	ClassDB::bind_method(D_METHOD("set_script_name", "script_name"), &DLScript::set_script_name);
+void GDNativeScript::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_library"), &GDNativeScript::get_library);
+	ClassDB::bind_method(D_METHOD("set_library", "library"), &GDNativeScript::set_library);
+	ClassDB::bind_method(D_METHOD("get_script_name"), &GDNativeScript::get_script_name);
+	ClassDB::bind_method(D_METHOD("set_script_name", "script_name"), &GDNativeScript::set_script_name);
 
-	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "DLLibrary"), "set_library", "get_library");
+	ADD_PROPERTYNZ(PropertyInfo(Variant::OBJECT, "library", PROPERTY_HINT_RESOURCE_TYPE, "GDNativeLibrary"), "set_library", "get_library");
 	ADD_PROPERTYNZ(PropertyInfo(Variant::STRING, "script_name"), "set_script_name", "get_script_name");
 }
 
-DLScript::DLScript() {
+GDNativeScript::GDNativeScript() {
 	script_data = NULL;
-	DLScriptLanguage::get_singleton()->script_list.insert(this);
+	GDNativeScriptLanguage::get_singleton()->script_list.insert(this);
 }
 
-DLScript::~DLScript() {
+GDNativeScript::~GDNativeScript() {
 	//hmm
-	DLScriptLanguage::get_singleton()->script_list.erase(this);
+	GDNativeScriptLanguage::get_singleton()->script_list.erase(this);
 }
 
 // Library
 
-DLLibrary *DLLibrary::currently_initialized_library = NULL;
+GDNativeLibrary *GDNativeLibrary::currently_initialized_library = NULL;
 
-DLLibrary *DLLibrary::get_currently_initialized_library() {
+GDNativeLibrary *GDNativeLibrary::get_currently_initialized_library() {
 	return currently_initialized_library;
 }
 
@@ -479,7 +478,7 @@ static const char *_dl_platforms_info[] = {
 	NULL // Finishing condition
 };
 
-void DLLibrary::set_platform_file(StringName p_platform, String p_file) {
+void GDNativeLibrary::set_platform_file(StringName p_platform, String p_file) {
 	if (p_file.empty()) {
 		platform_files.erase(p_platform);
 	} else {
@@ -487,7 +486,7 @@ void DLLibrary::set_platform_file(StringName p_platform, String p_file) {
 	}
 }
 
-String DLLibrary::get_platform_file(StringName p_platform) const {
+String GDNativeLibrary::get_platform_file(StringName p_platform) const {
 	if (platform_files.has(p_platform)) {
 		return platform_files[p_platform];
 	} else {
@@ -495,7 +494,7 @@ String DLLibrary::get_platform_file(StringName p_platform) const {
 	}
 }
 
-Error DLLibrary::_initialize() {
+Error GDNativeLibrary::_initialize() {
 	_THREAD_SAFE_METHOD_
 
 	// Get the file
@@ -529,24 +528,24 @@ Error DLLibrary::_initialize() {
 
 	StringName path = GlobalConfig::get_singleton()->globalize_path(platform_file);
 
-	DLLibrary::currently_initialized_library = this;
+	GDNativeLibrary::currently_initialized_library = this;
 
 	Error ret = NativeLibrary::initialize(native_library, path);
 	native_library->dllib = this;
 
-	DLLibrary::currently_initialized_library = NULL;
+	GDNativeLibrary::currently_initialized_library = NULL;
 
 	return ret;
 }
 
-Error DLLibrary::_terminate() {
+Error GDNativeLibrary::_terminate() {
 	ERR_FAIL_COND_V(!native_library, ERR_BUG);
 	ERR_FAIL_COND_V(!native_library->handle, ERR_BUG);
 
 	// de-init stuff
 
-	for (Map<StringName, DLScriptData *>::Element *E = native_library->scripts.front(); E; E = E->next()) {
-		for (Map<StringName, DLScriptData::Method>::Element *M = E->get()->methods.front(); M; M = M->next()) {
+	for (Map<StringName, GDNativeScriptData *>::Element *E = native_library->scripts.front(); E; E = E->next()) {
+		for (Map<StringName, GDNativeScriptData::Method>::Element *M = E->get()->methods.front(); M; M = M->next()) {
 			if (M->get().method.free_func) {
 				M->get().method.free_func(M->get().method.method_data);
 			}
@@ -558,7 +557,7 @@ Error DLLibrary::_terminate() {
 			E->get()->destroy_func.free_func(E->get()->destroy_func.method_data);
 		}
 
-		for (Set<DLScript *>::Element *S = DLScriptLanguage::get_singleton()->script_list.front(); S; S = S->next()) {
+		for (Set<GDNativeScript *>::Element *S = GDNativeScriptLanguage::get_singleton()->script_list.front(); S; S = S->next()) {
 			if (S->get()->script_data == E->get()) {
 				S->get()->script_data = NULL;
 			}
@@ -574,15 +573,15 @@ Error DLLibrary::_terminate() {
 	return ret;
 }
 
-void DLLibrary::_register_script(const StringName p_name, const StringName p_base, godot_instance_create_func p_instance_func, godot_instance_destroy_func p_destroy_func) {
+void GDNativeLibrary::_register_script(const StringName p_name, const StringName p_base, godot_instance_create_func p_instance_func, godot_instance_destroy_func p_destroy_func) {
 	ERR_FAIL_COND(!native_library);
 	ERR_FAIL_COND(native_library->scripts.has(p_name));
 
-	DLScriptData *s = memnew(DLScriptData);
+	GDNativeScriptData *s = memnew(GDNativeScriptData);
 	s->base = p_base;
 	s->create_func = p_instance_func;
 	s->destroy_func = p_destroy_func;
-	Map<StringName, DLScriptData *>::Element *E = native_library->scripts.find(p_base);
+	Map<StringName, GDNativeScriptData *>::Element *E = native_library->scripts.find(p_base);
 	if (E) {
 		s->base_data = E->get();
 		s->base_native_type = s->base_data->base_native_type;
@@ -598,16 +597,16 @@ void DLLibrary::_register_script(const StringName p_name, const StringName p_bas
 	native_library->scripts.insert(p_name, s);
 }
 
-void DLLibrary::_register_tool_script(const StringName p_name, const StringName p_base, godot_instance_create_func p_instance_func, godot_instance_destroy_func p_destroy_func) {
+void GDNativeLibrary::_register_tool_script(const StringName p_name, const StringName p_base, godot_instance_create_func p_instance_func, godot_instance_destroy_func p_destroy_func) {
 	ERR_FAIL_COND(!native_library);
 	ERR_FAIL_COND(native_library->scripts.has(p_name));
 
-	DLScriptData *s = memnew(DLScriptData);
+	GDNativeScriptData *s = memnew(GDNativeScriptData);
 	s->base = p_base;
 	s->create_func = p_instance_func;
 	s->destroy_func = p_destroy_func;
 	s->is_tool = true;
-	Map<StringName, DLScriptData *>::Element *E = native_library->scripts.find(p_base);
+	Map<StringName, GDNativeScriptData *>::Element *E = native_library->scripts.find(p_base);
 	if (E) {
 		s->base_data = E->get();
 		s->base_native_type = s->base_data->base_native_type;
@@ -623,23 +622,23 @@ void DLLibrary::_register_tool_script(const StringName p_name, const StringName
 	native_library->scripts.insert(p_name, s);
 }
 
-void DLLibrary::_register_script_method(const StringName p_name, const StringName p_method, godot_method_attributes p_attr, godot_instance_method p_func, MethodInfo p_info) {
+void GDNativeLibrary::_register_script_method(const StringName p_name, const StringName p_method, godot_method_attributes p_attr, godot_instance_method p_func, MethodInfo p_info) {
 	ERR_FAIL_COND(!native_library);
 	ERR_FAIL_COND(!native_library->scripts.has(p_name));
 
 	p_info.name = p_method;
-	DLScriptData::Method method;
+	GDNativeScriptData::Method method;
 
-	method = DLScriptData::Method(p_func, p_info, p_attr.rpc_type);
+	method = GDNativeScriptData::Method(p_func, p_info, p_attr.rpc_type);
 
 	native_library->scripts[p_name]->methods.insert(p_method, method);
 }
 
-void DLLibrary::_register_script_property(const StringName p_name, const String p_path, godot_property_attributes *p_attr, godot_property_set_func p_setter, godot_property_get_func p_getter) {
+void GDNativeLibrary::_register_script_property(const StringName p_name, const String p_path, godot_property_attributes *p_attr, godot_property_set_func p_setter, godot_property_get_func p_getter) {
 	ERR_FAIL_COND(!native_library);
 	ERR_FAIL_COND(!native_library->scripts.has(p_name));
 
-	DLScriptData::Property p;
+	GDNativeScriptData::Property p;
 
 	PropertyInfo pi;
 	pi.name = p_path;
@@ -647,18 +646,18 @@ void DLLibrary::_register_script_property(const StringName p_name, const String
 	if (p_attr != NULL) {
 		pi = PropertyInfo((Variant::Type)p_attr->type, p_path, (PropertyHint)p_attr->hint, *(String *)&p_attr->hint_string, p_attr->usage);
 
-		p = DLScriptData::Property(p_setter, p_getter, pi, *(Variant *)&p_attr->default_value, p_attr->rset_type);
+		p = GDNativeScriptData::Property(p_setter, p_getter, pi, *(Variant *)&p_attr->default_value, p_attr->rset_type);
 	}
 
 	native_library->scripts[p_name]->properties.insert(p_path, p);
 }
 
-void DLLibrary::_register_script_signal(const StringName p_name, const godot_signal *p_signal) {
+void GDNativeLibrary::_register_script_signal(const StringName p_name, const godot_signal *p_signal) {
 	ERR_FAIL_COND(!native_library);
 	ERR_FAIL_COND(!native_library->scripts.has(p_name));
 	ERR_FAIL_COND(!p_signal);
 
-	DLScriptData::Signal signal;
+	GDNativeScriptData::Signal signal;
 
 	signal.signal.name = *(String *)&p_signal->name;
 
@@ -698,7 +697,7 @@ void DLLibrary::_register_script_signal(const StringName p_name, const godot_sig
 	native_library->scripts[p_name]->signals_.insert(*(String *)&p_signal->name, signal);
 }
 
-DLScriptData *DLLibrary::get_script_data(const StringName p_name) {
+GDNativeScriptData *GDNativeLibrary::get_script_data(const StringName p_name) {
 	ERR_FAIL_COND_V(!native_library, NULL);
 
 	ERR_FAIL_COND_V(!native_library->scripts.has(p_name), NULL);
@@ -706,7 +705,7 @@ DLScriptData *DLLibrary::get_script_data(const StringName p_name) {
 	return native_library->scripts[p_name];
 }
 
-bool DLLibrary::_set(const StringName &p_name, const Variant &p_value) {
+bool GDNativeLibrary::_set(const StringName &p_name, const Variant &p_value) {
 	String name = p_name;
 	if (name.begins_with("platform/")) {
 		set_platform_file(name.get_slice("/", 1), p_value);
@@ -715,7 +714,7 @@ bool DLLibrary::_set(const StringName &p_name, const Variant &p_value) {
 	return false;
 }
 
-bool DLLibrary::_get(const StringName &p_name, Variant &r_ret) const {
+bool GDNativeLibrary::_get(const StringName &p_name, Variant &r_ret) const {
 	String name = p_name;
 	if (name.begins_with("platform/")) {
 		r_ret = get_platform_file(name.get_slice("/", 1));
@@ -724,7 +723,7 @@ bool DLLibrary::_get(const StringName &p_name, Variant &r_ret) const {
 	return false;
 }
 
-void DLLibrary::_get_property_list(List<PropertyInfo> *p_list) const {
+void GDNativeLibrary::_get_property_list(List<PropertyInfo> *p_list) const {
 	char **platform_info = (char **)_dl_platforms_info;
 
 	Set<String> registered_platform_names;
@@ -769,20 +768,20 @@ void DLLibrary::_get_property_list(List<PropertyInfo> *p_list) const {
 	}
 }
 
-void DLLibrary::_notification(int what) {
+void GDNativeLibrary::_notification(int what) {
 	// TODO
 }
 
-void DLLibrary::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_platform_file", "platform", "file"), &DLLibrary::set_platform_file);
-	ClassDB::bind_method(D_METHOD("get_platform_file", "platform"), &DLLibrary::get_platform_file);
+void GDNativeLibrary::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_platform_file", "platform", "file"), &GDNativeLibrary::set_platform_file);
+	ClassDB::bind_method(D_METHOD("get_platform_file", "platform"), &GDNativeLibrary::get_platform_file);
 }
 
-DLLibrary::DLLibrary() {
+GDNativeLibrary::GDNativeLibrary() {
 	native_library = NULL;
 }
 
-DLLibrary::~DLLibrary() {
+GDNativeLibrary::~GDNativeLibrary() {
 
 	if (!native_library) {
 		return;
@@ -795,7 +794,7 @@ DLLibrary::~DLLibrary() {
 
 // Instance
 
-bool DLInstance::set(const StringName &p_name, const Variant &p_value) {
+bool GDNativeInstance::set(const StringName &p_name, const Variant &p_value) {
 	if (!script->script_data)
 		return false;
 	if (script->script_data->properties.has(p_name)) {
@@ -805,7 +804,7 @@ bool DLInstance::set(const StringName &p_name, const Variant &p_value) {
 	return false;
 }
 
-bool DLInstance::get(const StringName &p_name, Variant &r_ret) const {
+bool GDNativeInstance::get(const StringName &p_name, Variant &r_ret) const {
 	if (!script->script_data)
 		return false;
 	if (script->script_data->properties.has(p_name)) {
@@ -816,12 +815,12 @@ bool DLInstance::get(const StringName &p_name, Variant &r_ret) const {
 	return false;
 }
 
-void DLInstance::get_property_list(List<PropertyInfo> *p_properties) const {
+void GDNativeInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 	script->get_script_property_list(p_properties);
 	// TODO: dynamic properties
 }
 
-Variant::Type DLInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
+Variant::Type GDNativeInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
 	if (script->script_data->properties.has(p_name)) {
 		*r_is_valid = true;
 		return script->script_data->properties[p_name].info.type;
@@ -830,20 +829,20 @@ Variant::Type DLInstance::get_property_type(const StringName &p_name, bool *r_is
 	return Variant::NIL;
 }
 
-void DLInstance::get_method_list(List<MethodInfo> *p_list) const {
+void GDNativeInstance::get_method_list(List<MethodInfo> *p_list) const {
 	script->get_script_method_list(p_list);
 }
 
-bool DLInstance::has_method(const StringName &p_method) const {
+bool GDNativeInstance::has_method(const StringName &p_method) const {
 	return script->has_method(p_method);
 }
 
-Variant DLInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+Variant GDNativeInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
 	// TODO: validated methods & errors
 
-	DLScriptData *data_ptr = script->script_data;
+	GDNativeScriptData *data_ptr = script->script_data;
 	while (data_ptr) {
-		Map<StringName, DLScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
+		Map<StringName, GDNativeScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
 		if (E) {
 			godot_variant result = E->get().method.method((godot_object *)owner, E->get().method.method_data, userdata, p_argcount, (godot_variant **)p_args);
 			return *(Variant *)&result;
@@ -854,12 +853,12 @@ Variant DLInstance::call(const StringName &p_method, const Variant **p_args, int
 	return Variant();
 }
 
-void DLInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
+void GDNativeInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {
 	// TODO: validated methods & errors
 
-	DLScriptData *data_ptr = script->script_data;
+	GDNativeScriptData *data_ptr = script->script_data;
 	while (data_ptr) {
-		Map<StringName, DLScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
+		Map<StringName, GDNativeScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
 		if (E) {
 			E->get().method.method((godot_object *)owner, E->get().method.method_data, userdata, p_argcount, (godot_variant **)p_args);
 		}
@@ -867,7 +866,7 @@ void DLInstance::call_multilevel(const StringName &p_method, const Variant **p_a
 	}
 }
 
-void DLInstance::_ml_call_reversed(DLScriptData *data_ptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
+void GDNativeInstance::_ml_call_reversed(GDNativeScriptData *data_ptr, const StringName &p_method, const Variant **p_args, int p_argcount) {
 	// TODO: validated methods & errors
 
 	if (data_ptr->base_data)
@@ -875,34 +874,34 @@ void DLInstance::_ml_call_reversed(DLScriptData *data_ptr, const StringName &p_m
 
 	// Variant::CallError ce;
 
-	Map<StringName, DLScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
+	Map<StringName, GDNativeScriptData::Method>::Element *E = data_ptr->methods.find(p_method);
 	if (E) {
 		E->get().method.method((godot_object *)owner, E->get().method.method_data, userdata, p_argcount, (godot_variant **)p_args);
 	}
 }
 
-void DLInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
+void GDNativeInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {
 	if (script.ptr() && script->script_data) {
 		_ml_call_reversed(script->script_data, p_method, p_args, p_argcount);
 	}
 }
 
-void DLInstance::notification(int p_notification) {
+void GDNativeInstance::notification(int p_notification) {
 	Variant value = p_notification;
 	const Variant *args[1] = { &value };
-	call_multilevel(DLScriptLanguage::singleton->strings._notification, args, 1);
+	call_multilevel(GDNativeScriptLanguage::singleton->strings._notification, args, 1);
 }
 
-Ref<Script> DLInstance::get_script() const {
+Ref<Script> GDNativeInstance::get_script() const {
 	return script;
 }
 
-ScriptLanguage *DLInstance::get_language() {
-	return DLScriptLanguage::singleton;
+ScriptLanguage *GDNativeInstance::get_language() {
+	return GDNativeScriptLanguage::singleton;
 }
 
-ScriptInstance::RPCMode DLInstance::get_rpc_mode(const StringName &p_method) const {
-	DLScriptData::Method m = script->script_data->methods[p_method];
+ScriptInstance::RPCMode GDNativeInstance::get_rpc_mode(const StringName &p_method) const {
+	GDNativeScriptData::Method m = script->script_data->methods[p_method];
 	switch (m.rpc_mode) {
 		case GODOT_METHOD_RPC_MODE_DISABLED:
 			return RPC_MODE_DISABLED;
@@ -919,8 +918,8 @@ ScriptInstance::RPCMode DLInstance::get_rpc_mode(const StringName &p_method) con
 	}
 }
 
-ScriptInstance::RPCMode DLInstance::get_rset_mode(const StringName &p_variable) const {
-	DLScriptData::Property p = script->script_data->properties[p_variable];
+ScriptInstance::RPCMode GDNativeInstance::get_rset_mode(const StringName &p_variable) const {
+	GDNativeScriptData::Property p = script->script_data->properties[p_variable];
 	switch (p.rset_mode) {
 		case GODOT_METHOD_RPC_MODE_DISABLED:
 			return RPC_MODE_DISABLED;
@@ -937,12 +936,12 @@ ScriptInstance::RPCMode DLInstance::get_rset_mode(const StringName &p_variable)
 	}
 }
 
-DLInstance::DLInstance() {
+GDNativeInstance::GDNativeInstance() {
 	owner = NULL;
 	userdata = NULL;
 }
 
-DLInstance::~DLInstance() {
+GDNativeInstance::~GDNativeInstance() {
 	if (script.is_valid()) {
 		if (owner) {
 			script->instances.erase(owner);
@@ -959,31 +958,31 @@ DLInstance::~DLInstance() {
 
 // Language
 
-DLScriptLanguage *DLScriptLanguage::singleton = NULL;
+GDNativeScriptLanguage *GDNativeScriptLanguage::singleton = NULL;
 
-String DLScriptLanguage::get_name() const {
-	return "DLScript";
+String GDNativeScriptLanguage::get_name() const {
+	return "Native";
 }
 
 void _add_reload_node() {
 #ifdef TOOLS_ENABLED
-	DLReloadNode *rn = memnew(DLReloadNode);
+	GDNativeReloadNode *rn = memnew(GDNativeReloadNode);
 	EditorNode::get_singleton()->add_child(rn);
 #endif
 }
 
-void DLScriptLanguage::init() {
+void GDNativeScriptLanguage::init() {
 	// TODO: Expose globals
-	GLOBAL_DEF("dlscript/default_dllibrary", "");
-	PropertyInfo prop_info(Variant::STRING, "dlscript/default_dllibrary", PROPERTY_HINT_FILE, "tres,res,dllib");
-	GlobalConfig::get_singleton()->set_custom_property_info("dlscript/default_dllibrary", prop_info);
+	GLOBAL_DEF("gdnative/default_gdnativelibrary", "");
+	PropertyInfo prop_info(Variant::STRING, "gdnative/default_gdnativelibrary", PROPERTY_HINT_FILE, "tres,res,dllib");
+	GlobalConfig::get_singleton()->set_custom_property_info("gdnative/default_gdnativelibrary", prop_info);
 
 // generate bindings
 #if defined(TOOLS_ENABLED) && defined(DEBUG_METHODS_ENABLED)
 
 	List<String> args = OS::get_singleton()->get_cmdline_args();
 
-	List<String>::Element *E = args.find("--dlscript-generate-json-api");
+	List<String>::Element *E = args.find("--gdnative-generate-json-api");
 
 	if (E && E->next()) {
 		if (generate_c_api(E->next()->get()) != OK) {
@@ -999,162 +998,160 @@ void DLScriptLanguage::init() {
 #endif
 }
 
-String DLScriptLanguage::get_type() const {
-	return "DLScript";
+String GDNativeScriptLanguage::get_type() const {
+	return "Native";
 }
 
-String DLScriptLanguage::get_extension() const {
-	return "dl";
+String GDNativeScriptLanguage::get_extension() const {
+	return "gdn";
 }
 
-Error DLScriptLanguage::execute_file(const String &p_path) {
+Error GDNativeScriptLanguage::execute_file(const String &p_path) {
 	return OK; // ??
 }
 
-void DLScriptLanguage::finish() {
+void GDNativeScriptLanguage::finish() {
 	// cleanup is for noobs
 }
 
 // scons doesn't want to link in the api source so we need to call a dummy function to cause it to link
 extern "C" void _api_anchor();
 
-void DLScriptLanguage::_compile_dummy_for_the_api() {
+void GDNativeScriptLanguage::_compile_dummy_for_the_api() {
 	_api_anchor();
 }
 
-Ref<Script> DLScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
-	DLScript *src = memnew(DLScript);
+Ref<Script> GDNativeScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
+	GDNativeScript *src = memnew(GDNativeScript);
 	src->set_script_name(p_class_name);
-	return Ref<DLScript>(src);
+	return Ref<GDNativeScript>(src);
 }
 
-bool DLScriptLanguage::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) const {
+bool GDNativeScriptLanguage::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) const {
 	return false; // TODO
 }
 
-Script *DLScriptLanguage::create_script() const {
-	DLScript *scr = memnew(DLScript);
+Script *GDNativeScriptLanguage::create_script() const {
+	GDNativeScript *scr = memnew(GDNativeScript);
 	return scr;
 }
 
-bool DLScriptLanguage::has_named_classes() const {
+bool GDNativeScriptLanguage::has_named_classes() const {
 	return true;
 }
 
-int DLScriptLanguage::find_function(const String &p_function, const String &p_code) const {
+int GDNativeScriptLanguage::find_function(const String &p_function, const String &p_code) const {
 	return -1; // No source code!
 }
 
-String DLScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
+String GDNativeScriptLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
 	return ""; // No source code!
 }
 
-void DLScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
+void GDNativeScriptLanguage::add_global_constant(const StringName &p_variable, const Variant &p_value) {
 	// TODO TODO TODO
 }
 
 // TODO: Any debugging? (research)
-String DLScriptLanguage::debug_get_error() const {
+String GDNativeScriptLanguage::debug_get_error() const {
 	return "";
 }
 
-int DLScriptLanguage::debug_get_stack_level_count() const {
+int GDNativeScriptLanguage::debug_get_stack_level_count() const {
 	return 1; // ?
 }
 
-int DLScriptLanguage::debug_get_stack_level_line(int p_level) const {
+int GDNativeScriptLanguage::debug_get_stack_level_line(int p_level) const {
 	return -1;
 }
 
-String DLScriptLanguage::debug_get_stack_level_function(int p_level) const {
+String GDNativeScriptLanguage::debug_get_stack_level_function(int p_level) const {
 	return "[native code]"; // ?
 }
 
-String DLScriptLanguage::debug_get_stack_level_source(int p_level) const {
+String GDNativeScriptLanguage::debug_get_stack_level_source(int p_level) const {
 	return "";
 }
 
-void DLScriptLanguage::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 GDNativeScriptLanguage::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 DLScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
+void GDNativeScriptLanguage::debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
 
-String DLScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
+String GDNativeScriptLanguage::debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) {
 	return ""; // ??
 }
 
-void DLScriptLanguage::reload_all_scripts() {
+void GDNativeScriptLanguage::reload_all_scripts() {
 	// @Todo
 }
 
-void DLScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
+void GDNativeScriptLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {
 	// @Todo
 	OS::get_singleton()->print("reload tool scripts\n");
 }
 
-void DLScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
-	p_extensions->push_back("dl"); // Container file format
+void GDNativeScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back("gdn"); // Container file format
 }
 
-void DLScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
+void GDNativeScriptLanguage::get_public_functions(List<MethodInfo> *p_functions) const {
 }
 
-void DLScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
+void GDNativeScriptLanguage::get_public_constants(List<Pair<String, Variant> > *p_constants) const {
 }
 
 // TODO: all profilling
-void DLScriptLanguage::profiling_start() {
+void GDNativeScriptLanguage::profiling_start() {
 }
 
-void DLScriptLanguage::profiling_stop() {
+void GDNativeScriptLanguage::profiling_stop() {
 }
 
-int DLScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
+int GDNativeScriptLanguage::profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) {
 	return 0;
 }
 
-int DLScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
+int GDNativeScriptLanguage::profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) {
 	return 0;
 }
 
-void DLScriptLanguage::frame() {
+void GDNativeScriptLanguage::frame() {
 }
 
-String DLScriptLanguage::get_init_symbol_name() {
-	return "godot_dlscript_init"; // TODO: Maybe make some internal function which would do the actual stuff
+String GDNativeScriptLanguage::get_init_symbol_name() {
+	return "godot_native_init"; // TODO: Maybe make some internal function which would do the actual stuff
 }
 
-String DLScriptLanguage::get_terminate_symbol_name() {
-	return "godot_dlscript_terminate";
+String GDNativeScriptLanguage::get_terminate_symbol_name() {
+	return "godot_native_terminate";
 }
 
-DLScriptLanguage::DLScriptLanguage() {
+GDNativeScriptLanguage::GDNativeScriptLanguage() {
 	ERR_FAIL_COND(singleton);
 	strings._notification = StringName("_notification");
 	singleton = this;
 	initialized_libraries = Map<StringName, NativeLibrary *>();
 }
 
-DLScriptLanguage::~DLScriptLanguage() {
+GDNativeScriptLanguage::~GDNativeScriptLanguage() {
 	singleton = NULL;
 }
 
 // DLReloadNode
 
-void DLReloadNode::_bind_methods() {
-	ClassDB::bind_method("_notification", &DLReloadNode::_notification);
+void GDNativeReloadNode::_bind_methods() {
+	ClassDB::bind_method("_notification", &GDNativeReloadNode::_notification);
 }
 
-void DLReloadNode::_notification(int p_what) {
+void GDNativeReloadNode::_notification(int p_what) {
 #ifdef TOOLS_ENABLED
 
 	switch (p_what) {
 		case MainLoop::NOTIFICATION_WM_FOCUS_IN: {
 
-			// break; // For now.
-
 			Set<NativeLibrary *> libs_to_reload;
 
-			for (Map<StringName, NativeLibrary *>::Element *L = DLScriptLanguage::get_singleton()->initialized_libraries.front(); L; L = L->next()) {
+			for (Map<StringName, NativeLibrary *>::Element *L = GDNativeScriptLanguage::get_singleton()->initialized_libraries.front(); L; L = L->next()) {
 				// check if file got modified at all
 				// @Todo
 
@@ -1163,16 +1160,16 @@ void DLReloadNode::_notification(int p_what) {
 
 			for (Set<NativeLibrary *>::Element *L = libs_to_reload.front(); L; L = L->next()) {
 
-				DLLibrary *lib = L->get()->dllib;
+				GDNativeLibrary *lib = L->get()->dllib;
 
 				lib->_terminate();
 				lib->_initialize();
 
 				// update placeholders (if any)
 
-				DLScript *script = NULL;
+				GDNativeScript *script = NULL;
 
-				for (Set<DLScript *>::Element *S = DLScriptLanguage::get_singleton()->script_list.front(); S; S = S->next()) {
+				for (Set<GDNativeScript *>::Element *S = GDNativeScriptLanguage::get_singleton()->script_list.front(); S; S = S->next()) {
 					if (lib->native_library->scripts.has(S->get()->get_script_name())) {
 						script = S->get();
 						script->script_data = lib->get_script_data(script->get_script_name());
@@ -1203,35 +1200,35 @@ void DLReloadNode::_notification(int p_what) {
 
 // Resource loader/saver
 
-RES ResourceFormatLoaderDLScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+RES ResourceFormatLoaderGDNativeScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	ResourceFormatLoaderText rsflt;
 	return rsflt.load(p_path, p_original_path, r_error);
 }
 
-void ResourceFormatLoaderDLScript::get_recognized_extensions(List<String> *p_extensions) const {
-	p_extensions->push_back("dl");
+void ResourceFormatLoaderGDNativeScript::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back("gdn");
 }
-bool ResourceFormatLoaderDLScript::handles_type(const String &p_type) const {
-	return (p_type == "Script" || p_type == "DLScript");
+bool ResourceFormatLoaderGDNativeScript::handles_type(const String &p_type) const {
+	return (p_type == "Script" || p_type == "Native");
 }
-String ResourceFormatLoaderDLScript::get_resource_type(const String &p_path) const {
+String ResourceFormatLoaderGDNativeScript::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == "dl")
-		return "DLScript";
+	if (el == "gdn")
+		return "Native";
 	return "";
 }
 
-Error ResourceFormatSaverDLScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
+Error ResourceFormatSaverGDNativeScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
 	ResourceFormatSaverText rfst;
 	return rfst.save(p_path, p_resource, p_flags);
 }
 
-bool ResourceFormatSaverDLScript::recognize(const RES &p_resource) const {
-	return p_resource->cast_to<DLScript>() != NULL;
+bool ResourceFormatSaverGDNativeScript::recognize(const RES &p_resource) const {
+	return p_resource->cast_to<GDNativeScript>() != NULL;
 }
 
-void ResourceFormatSaverDLScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
-	if (p_resource->cast_to<DLScript>()) {
-		p_extensions->push_back("dl");
+void ResourceFormatSaverGDNativeScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
+	if (p_resource->cast_to<GDNativeScript>()) {
+		p_extensions->push_back("gdn");
 	}
 }