Add GodotJavaScriptLanguage

Author: gschwind

bridge/jsb_class_info.cpp

@@ -238,7 +238,7 @@ namespace jsb
     void ScriptClassInfo::instantiate(const StringName& p_module_id, const v8::Local<v8::Object>& p_self)
     {
         const String source_path = internal::PathUtil::convert_javascript_path(p_module_id);
-        const Ref<GodotJSScript> script = ResourceLoader::load(source_path);
+        const Ref<GodotJSScriptBase> script = ResourceLoader::load(source_path);
         if (script.is_valid())
         {
             jsb_unused(script->can_instantiate()); // make it loaded immediately

internal/jsb_string_names.h

@@ -6,22 +6,24 @@
 #define jsb_string_name(name) ::jsb::internal::StringNames::get_singleton().sn_##name
 #define jsb_literal(name) (sizeof(::jsb::internal::StringNames::sn_##name) == sizeof(StringName), #name)
 
-class GodotJSScriptLanguage;
+class GodotJSScriptLanguageBase;
 
 namespace jsb::internal
 {
     class StringNames
     {
     private:
-        friend class ::GodotJSScriptLanguage;
+        friend class ::GodotJSScriptLanguageBase;
 
         static StringNames* singleton_;
 
         static void create() { singleton_ = memnew(StringNames); }
         static void free()
         {
-            memdelete(singleton_);
-            singleton_ = nullptr;
+            if (singleton_) {
+                memdelete(singleton_);
+                singleton_ = nullptr;
+            }
         }
 
         // we need to ignore some names used in godot (such as XXX.name) to avoid conflicts in javascript.

register_types.cpp

@@ -12,7 +12,6 @@
 #include "weaver-editor/jsb_export_plugin.h"
 #endif
 
-static GodotJSScriptLanguage* script_language_js;
 static Ref<ResourceFormatLoaderGodotJSScript> resource_loader;
 static Ref<ResourceFormatSaverGodotJSScript> resource_saver;
 
@@ -21,29 +20,31 @@ void jsb_initialize_module(ModuleInitializationLevel p_level)
     if (p_level == MODULE_INITIALIZATION_LEVEL_SERVERS)
     {
         GDREGISTER_CLASS(GodotJSScript);
+        GDREGISTER_CLASS(GodotJavaScript);
 
         jsb::impl::GlobalInitialize::init();
 
         // register javascript language
-        script_language_js = memnew(GodotJSScriptLanguage());
-        ScriptServer::register_language(script_language_js);
+        ScriptServer::register_language(GodotJSScriptLanguage::create_singleton());
+        ScriptServer::register_language(GodotJavascriptLanguage::create_singleton());
 
         resource_loader.instantiate();
-        resource_loader->register_resource_extension(JSB_TYPESCRIPT_EXT, script_language_js);
-        resource_loader->register_resource_extension(JSB_JAVASCRIPT_EXT, script_language_js);
+        resource_loader->register_resource_extension(JSB_TYPESCRIPT_EXT, GodotJSScriptLanguage::get_singleton());
+        resource_loader->register_resource_extension(JSB_JAVASCRIPT_EXT, GodotJavascriptLanguage::get_singleton());
         ResourceLoader::add_resource_format_loader(resource_loader);
 
         resource_saver.instantiate();
         ResourceSaver::add_resource_format_saver(resource_saver);
 
+
 #ifdef TOOLS_ENABLED
         EditorNode::add_init_callback([]
         {
-            GodotJSEditorPlugin* plugin = memnew(GodotJSEditorPlugin(script_language_js));
+            GodotJSEditorPlugin* plugin = memnew(GodotJSEditorPlugin(GodotJSScriptLanguage::get_singleton()));
             EditorNode::add_editor_plugin(plugin);
 
             Ref<GodotJSExportPlugin> exporter;
-            exporter.instantiate(script_language_js->get_environment());
+            exporter.instantiate(GodotJSScriptLanguage::get_singleton()->get_environment());
             EditorExport::get_singleton()->add_export_plugin(exporter);
 
             plugin->set_name(jsb_typename(GodotJSEditorPlugin));
@@ -62,8 +63,10 @@ void jsb_uninitialize_module(ModuleInitializationLevel p_level)
         ResourceSaver::remove_resource_format_saver(resource_saver);
         resource_saver.unref();
 
-        jsb_check(script_language_js);
-        ScriptServer::unregister_language(script_language_js);
-        memdelete(script_language_js);
+        ScriptServer::unregister_language(GodotJSScriptLanguage::get_singleton());
+        GodotJSScriptLanguage::destroy_singleton();
+
+        ScriptServer::unregister_language(GodotJavascriptLanguage::get_singleton());
+        GodotJavascriptLanguage::destroy_singleton();
     }
 }

weaver-editor/icons/GodotJavaScript.svg

@@ -4,7 +4,7 @@
 #include "jsb_script.h"
 
 
-void ResourceFormatLoaderGodotJSScript::register_resource_extension(String ext, GodotJSScriptLanguage * lang)
+void ResourceFormatLoaderGodotJSScript::register_resource_extension(String ext, GodotJSScriptLanguageBase * lang)
 {
     lang_map_.insert(ext, lang);
 }
@@ -13,7 +13,7 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
 {
     JSB_BENCHMARK_SCOPE(ResourceFormatLoaderGodotJSScript, load);
 
-    GodotJSScriptLanguage * lang = nullptr;
+    GodotJSScriptLanguageBase * lang = nullptr;
     for (auto const & i: lang_map_) {
         if (p_path.ends_with(i.key)) {
             lang = i.value;
@@ -29,7 +29,7 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
     {
         //TODO a dirty but approaching solution for hot-reloading
         MutexLock lock(lang->mutex_);
-        SelfList<GodotJSScript> *elem = lang->script_list_.first();
+        SelfList<GodotJSScriptBase> *elem = lang->script_list_.first();
         while (elem)
         {
             if (elem->self()->get_path() == p_path)
@@ -68,7 +68,7 @@ Ref<Resource> ResourceFormatLoaderGodotJSScript::load(const String& p_path, cons
     JSB_LOG(VeryVerbose, "loading script resource %s on thread %s", p_path, uitos(Thread::get_caller_id()));
 
     // return a skeleton script which only contains path and source code without actually loaded in `realm` since `load` may called from background threads
-    Ref<GodotJSScript> spt = reinterpret_cast<GodotJSScript*>(lang->create_script());
+    Ref<GodotJSScriptBase> spt = lang->create_godotjsscript();
     spt->attach_source(p_path);
     if (r_error) *r_error = OK;
     return spt;

weaver/jsb_resource_loader.cpp

@@ -11,12 +11,12 @@ class ResourceFormatLoaderGodotJSScript : public ResourceFormatLoader
     ResourceFormatLoaderGodotJSScript(ResourceFormatLoaderGodotJSScript const &) = delete;
     ResourceFormatLoaderGodotJSScript & operator=(ResourceFormatLoaderGodotJSScript const &) = delete;
 
-    HashMap<String, GodotJSScriptLanguage *> lang_map_;
+    HashMap<String, GodotJSScriptLanguageBase *> lang_map_;
 
 public:
     ResourceFormatLoaderGodotJSScript() { }
 
-    void register_resource_extension(String ext, GodotJSScriptLanguage * lang);
+    void register_resource_extension(String ext, GodotJSScriptLanguageBase * lang);
 
     virtual Ref<Resource> load(const String& p_path, const String& p_original_path = "", Error* r_error = nullptr, bool p_use_sub_threads = false, float* r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
     virtual void get_recognized_extensions(List<String>* p_extensions) const override;

weaver/jsb_resource_loader.h

@@ -6,14 +6,14 @@
 // @seealso: gdscript.cpp ResourceFormatSaverGDScript::save
 Error ResourceFormatSaverGodotJSScript::save(const Ref<Resource>& p_resource, const String& p_path, uint32_t p_flags)
 {
-    const Ref<GodotJSScript> sqscr = p_resource;
+    const Ref<GodotJSScriptBase> sqscr = p_resource;
     ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);
 
     Error err;
     const Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);
     if (err)
     {
-        JSB_LOG(Error, "Cannot save %s file '%s'.", jsb_typename(GodotJSScript), p_path);
+        JSB_LOG(Error, "Cannot save %s file '%s'.", jsb_typename(GodotJSScriptBase), p_path);
         return err;
     }
     file->store_string(sqscr->get_source_code());
@@ -33,7 +33,7 @@ Error ResourceFormatSaverGodotJSScript::save(const Ref<Resource>& p_resource, co
 
 void ResourceFormatSaverGodotJSScript::get_recognized_extensions(const Ref<Resource>& p_resource, List<String>* p_extensions) const
 {
-    if (Object::cast_to<GodotJSScript>(*p_resource))
+    if (Object::cast_to<GodotJSScriptBase>(*p_resource))
     {
         p_extensions->push_back(JSB_TYPESCRIPT_EXT);
         p_extensions->push_back(JSB_JAVASCRIPT_EXT);
@@ -42,5 +42,5 @@ void ResourceFormatSaverGodotJSScript::get_recognized_extensions(const Ref<Resou
 
 bool ResourceFormatSaverGodotJSScript::recognize(const Ref<Resource>& p_resource) const
 {
-    return Object::cast_to<GodotJSScript>(*p_resource) != nullptr;
+    return Object::cast_to<GodotJSScriptBase>(*p_resource) != nullptr;
 }