Setup SynthInstance class + Host functions support

Author: Mallowwww

src/main/java/com/synthmodloader/modloader/integration/ChicoryIntegration.java

@@ -1,22 +1,47 @@
 package com.synthmodloader.modloader.integration;
 
-import com.dylibso.chicory.runtime.ExportFunction; // works fine
-import com.dylibso.chicory.wasm.Parser; // breaks
+import com.dylibso.chicory.runtime.HostFunction;
 import com.dylibso.chicory.runtime.Instance;
+import com.dylibso.chicory.wasm.types.FunctionType;
+import com.dylibso.chicory.wasm.types.ValType;
 import com.synthmodloader.modloader.SynthModLoader;
+import com.synthmodloader.modloader.synth.SynthInstance;
+import net.minecraft.resources.ResourceLocation;
 
-import java.io.IOException;
+import java.util.List;
 
 public class ChicoryIntegration {
     public static void init() {
         ClassLoader classloader = Thread.currentThread().getContextClassLoader();
         try {
-            var module = Parser.parse(classloader.getResourceAsStream("test.wasm"));
-            Instance instance = Instance.builder(module).build();
-            ExportFunction testFunction = instance.export("testFunction");
-            SynthModLoader.LOGGER.info("OUTPUT: " + testFunction.apply(1)[0]);
+//            var module = Parser.parse(classloader.getResourceAsStream("test.wasm"));
+//            Instance instance = Instance.builder(module).build();
+//            ExportFunction testFunction = instance.export("iterFact");
+            var synth = SynthInstance.Builder.create()
+                    .location(ResourceLocation.fromNamespaceAndPath("sml", "data/logger.wasm"))
+                    .function(new HostFunction(
+                            "console",
+                            "log",
+                            FunctionType.of(
+                                    List.of(ValType.I32, ValType.I32),
+                                    List.of()
+                            ),
+                            ChicoryIntegration::log
+                    ))
+                    .build();
+            var testFunction = synth.export("logIt").orElseThrow();
+            testFunction.apply();
+            SynthModLoader.LOGGER.info("OUTPUT");
+
         } catch(Exception e) {
             SynthModLoader.LOGGER.error("Error loading test module !", e);
         }
     }
+    private static long[] log(Instance instance, long... args) {
+        var len = (int) args[0];
+        var offset = (int) args[1];
+        var message = instance.memory().readString(offset, len);
+        SynthModLoader.LOGGER.info(message);
+        return null;
+    }
 }

src/main/java/com/synthmodloader/modloader/synth/SynthInstance.java

@@ -0,0 +1,73 @@
+package com.synthmodloader.modloader.synth;
+
+import com.dylibso.chicory.runtime.ExportFunction;
+import com.dylibso.chicory.runtime.HostFunction;
+import com.dylibso.chicory.runtime.Instance;
+import com.dylibso.chicory.runtime.Store;
+import com.dylibso.chicory.wasm.Parser;
+import com.synthmodloader.modloader.SynthModLoader;
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.fml.ModContainer;
+import net.neoforged.fml.ModList;
+import net.neoforged.fml.ModLoader;
+import net.neoforged.neoforge.server.ServerLifecycleHooks;
+
+import java.io.IOException;
+import java.time.chrono.MinguoEra;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+
+public class SynthInstance {
+    public final ResourceLocation location;
+    private final Instance wasmInstance;
+    private SynthInstance(ResourceLocation _location, Collection<HostFunction> functions) throws IOException {
+        location = _location;
+        var store = new Store();
+        functions.forEach(store::addFunction);
+        if (ModList.get().getModFileById(location.getNamespace()) == null)
+            throw new IllegalArgumentException("Namespace `" + location.getNamespace() + "` does not exist !");
+        var path = ModList.get().getModFileById(location.getNamespace()).getFile().findResource(location.getPath());
+        wasmInstance = store.instantiate(location.getPath(), Parser.parse(path));
+    }
+
+    public Optional<ExportFunction> export(String functionName) {
+        if (wasmInstance != null && wasmInstance.export(functionName) != null)
+            return Optional.of(wasmInstance.export(functionName));
+        else
+            return Optional.empty();
+
+    }
+
+    public static class Builder {
+        private List<HostFunction> functions;
+        private ResourceLocation location;
+        private Builder() {}
+
+        public Builder function(HostFunction function) {
+            functions.add(function);
+            return this;
+        }
+        public Builder location(ResourceLocation location) {
+            this.location = location;
+            return this;
+        }
+        public SynthInstance build() {
+            try {
+                return new SynthInstance(location, functions);
+            } catch (Exception e) {
+                SynthModLoader.LOGGER.error("Couldn't create SynthInstance !", e);
+            }
+            return null;
+
+        }
+
+        public static Builder create() {
+            var builder = new Builder();
+            builder.functions = new ArrayList<>();
+            return builder;
+        }
+    }
+}