Extensions refactor (#81)

* Restructure extensions subdir

* Rename

* Extension base class

* WIP: Header-only WASI Preview 1 extension

* Finalize header-only WASI Preview 1 extension

* Remove permissions, add enabled extensions list

* Update tests

* Formatting

* Docs

* Prepare for Godot 3.x backport

Author: ashtonmeuser

SConstruct

@@ -54,7 +54,7 @@ env.Append(CPPPATH=[".", "{}/include".format(env["wasm_runtime"])])
 env.Append(LIBS=[runtime_lib])
 
 # Godot Wasm sources
-source = ["register_types.cpp", env.Glob("src/*.cpp")]
+source = ["register_types.cpp", env.Glob("src/*.cpp"), env.Glob("src/extensions/*.cpp")]
 
 # Builders
 library = env.SharedLibrary(target="addons/godot-wasm/bin/{}/godot-wasm".format(env["platform"]), source=source)

SCsub

@@ -51,5 +51,9 @@ module_env.Append(CPPDEFINES=["GODOT_MODULE", "LIBWASM_STATIC"])
 
 # Module sources
 module_env.add_source_files(
-    env.modules_sources, ["register_types.cpp", env.Glob("src/*.cpp", exclude="src/godot-library.cpp")]
+    env.modules_sources, [
+        "register_types.cpp",
+        env.Glob("src/*.cpp", exclude="src/godot-library.cpp"),
+        env.Glob("src/extensions/*.cpp")
+    ]
 )

doc_classes/Wasm.xml

@@ -69,5 +69,8 @@
 		<member name="memory" type="WasmMemory" setter="" getter="get_memory">
 			A [StreamPeer] interface for interacting with the memory of an instantiated Wasm module.
 		</member>
+		<member name="extensions" type="PackedStringArray" setter="set_extensions" getter="get_extensions">
+			An array of strings listing enabled extensions that satisfy Wasm module imports.
+		</member>
 	</members>
 </class>

examples/wasm-test/TestWasi.gd

@@ -43,28 +43,11 @@ func test_clock_time_get():
 	var result = wasm.function("clock_time_get", [])
 	expect_within(result, time, 1000.0) # Within one second
 
-func test_permissions():
-	var wasm = load_wasm("wasi")
-	expect_includes(wasm.permissions, "print")
-	expect_eq(wasm.permissions.get("print"), true)
-	wasm.permissions = { "print": false }
-	expect_eq(wasm.permissions.get("print"), false)
-	var permission = wasm.has_permission("print")
-	expect_eq(permission, false)
-	wasm.permissions = { "print": true }
-	permission = wasm.has_permission("print")
-	expect_eq(permission, true)
-
-func test_invalid_permissions():
-	# TODO: No exit permissions causes crash on proc_exit
-	# TODO: Args & env not affected by permissions
-	var wasm = load_wasm("wasi")
-	wasm.permissions = { "print": false }
-	wasm.function("fd_write", [])
-	expect_error("Failed calling function fd_write")
-	wasm.permissions = { "print": true, "random": false }
-	wasm.function("random_get", [])
-	expect_error("Failed calling function random_get")
-	wasm.permissions = { "random": true, "time": false }
-	wasm.function("clock_time_get", [])
-	expect_error("Failed calling function clock_time_get")
+func test_disable_extension():
+	var wasm = Wasm.new()
+	var buffer = read_file("wasi")
+	expect_includes(wasm.extensions, "wasi_preview1")
+	wasm.extensions = [] # Remove all extensions
+	var error = wasm.load(buffer, {})
+	expect_eq(error, ERR_CANT_CREATE)
+	expect_error("Missing import function wasi_snapshot_preview1.args_get")

examples/wasm-test/utils/TestSuite.gd

@@ -76,14 +76,22 @@ func expect_includes(o, v: String):
 		if !o.keys().has(v): _fail("Expect contains: %s ∉ %s" % [v, o.keys()])
 	elif o is Array:
 		if !o.has(v): _fail("Expect contains: %s ∉ %s" % [v, o])
-	else: _fail("Expect contains: Invalid object")
+	else:
+		var a = Array(o) # May be a packed array; attempt cast
+		if a != null:
+			if !a.has(v): _fail("Expect contains: %s ∉ %s" % [v, a])
+		else: _fail("Expect contains: Invalid object")
 
 func expect_excludes(o, v: String):
 	if o is Dictionary:
 		if o.keys().has(v): _fail("Expect excludes: %s ∈ %s" % [v, o.keys()])
 	elif o is Array:
 		if o.has(v): _fail("Expect excludes: %s ∈ %s" % [v, o])
-	else: _fail("Expect excludes: Invalid object")
+	else:
+		var a = Array(o) # May be a packed array; attempt cast
+		if a != null:
+			if !a.has(v): _fail("Expect contains: %s ∈ %s" % [v, a])
+		else: _fail("Expect excludes: Invalid object")
 
 # General utils
 

src/defs.h

@@ -42,6 +42,7 @@ Useful for minimizing changes to implementation files between targets e.g. GDExt
 #define FAIL_IF(cond, message, ret) if (unlikely(cond)) FAIL(message, ret)
 #define INSTANTIATE_REF(ref) ref.instantiate()
 #define BYTE_ARRAY_POINTER(array) array.ptr()
+#define PACKED_ARRAY_HAS(array, value) array.has(value)
 #define CMDLINE_ARGS OS::get_singleton()->get_cmdline_user_args()
 #define TIME_REALTIME Time::get_singleton()->get_unix_time_from_system() * 1000000000
 #define TIME_MONOTONIC Time::get_singleton()->get_ticks_usec() * 1000

src/extensions/extension.h

@@ -0,0 +1,72 @@
+#ifndef GODOT_WASM_EXTENSION_H
+#define GODOT_WASM_EXTENSION_H
+
+#include <map>
+#include <string>
+#include <vector>
+#include <wasm.h>
+#include "../defs.h"
+#include "../defer.h"
+#include "../store.h"
+
+namespace godot {
+  class Wasm; // Forward declare to avoid circular dependency
+
+  namespace godot_wasm {
+    typedef wasm_trap_t* (*extension_callback_t)(Wasm*, const wasm_val_vec_t*, wasm_val_vec_t*);
+    typedef std::tuple<std::vector<wasm_valkind_enum>, std::vector<wasm_valkind_enum>, extension_callback_t> callback_signature;
+
+    class Extension {
+      private:
+        Wasm* wasm; // Non-owning pointer to the Wasm instance
+        std::map<std::string, callback_signature> signatures;
+
+        wasm_func_t* create_callback(const callback_signature& signature) {
+          const auto& param_types = std::get<0>(signature);
+          const auto& result_types = std::get<1>(signature);
+
+          wasm_valtype_vec_t params;
+          wasm_valtype_vec_new_uninitialized(&params, param_types.size());
+          for (size_t i = 0; i < param_types.size(); i++) params.data[i] = wasm_valtype_new(param_types[i]);
+          DEFER(wasm_valtype_vec_delete(&params));
+
+          wasm_valtype_vec_t results;
+          wasm_valtype_vec_new_uninitialized(&results, result_types.size());
+          for (size_t i = 0; i < result_types.size(); i++) results.data[i] = wasm_valtype_new(result_types[i]);
+          DEFER(wasm_valtype_vec_delete(&results));
+
+          wasm_functype_t* functype = wasm_functype_new(&params, &results);
+          DEFER(wasm_functype_delete(functype));
+
+          extension_callback_t callback = std::get<2>(signature);
+
+          return wasm_func_new_with_env(STORE, functype, (wasm_func_callback_with_env_t)callback, wasm, NULL);
+        }
+
+      protected:
+        void register_callback(
+          const String& import_name,
+          const std::vector<wasm_valkind_enum>& param_types,
+          const std::vector<wasm_valkind_enum>& result_types,
+          extension_callback_t callback
+        ) {
+          std::string key = std::string(import_name.utf8().get_data());
+          signatures[key] = std::make_tuple(param_types, result_types, callback);
+        }
+
+      public:
+        Extension(Wasm* wasm_instance): wasm(wasm_instance) {}
+        virtual ~Extension() {}
+
+        virtual wasm_func_t* get_callback(const String &name) final {
+          std::string key = std::string(name.utf8().get_data());
+          if (signatures.count(key)) {
+            return create_callback(signatures[key]);
+          }
+          return NULL;
+        }
+    };
+  }
+}
+
+#endif