Implement the linking example

Author: Luukdegram

example/interrupt.zig

@@ -18,8 +18,7 @@ pub fn main() !void {
     const wasm = try wasm_file.readToEndAlloc(ga, std.math.maxInt(u64));
     defer ga.free(wasm);
 
-    const config = try wasmtime.Config.init();
-    config.setInterruptable(true);
+    const config = try wasmtime.Config.init(.{ .interruptable = true });
     var engine = try wasmtime.Engine.withConfig(config);
     defer engine.deinit();
     std.debug.print("Engine initialized...\n", .{});

example/linking.zig

@@ -0,0 +1,104 @@
+const std = @import("std");
+const wasmtime = @import("wasmtime");
+const builtin = std.builtin;
+const fs = std.fs;
+const ga = std.heap.c_allocator;
+const Allocator = std.mem.Allocator;
+
+pub fn main() !void {
+    const wasm_path = if (builtin.os.tag == .windows) "example\\linking1.wat" else "example/linking1.wat";
+    const wasm_path2 = if (builtin.os.tag == .windows) "example\\linking2.wat" else "example/linking2.wat";
+    const wasm_file = try fs.cwd().openFile(wasm_path, .{});
+    defer wasm_file.close();
+    const wasm_file2 = try fs.cwd().openFile(wasm_path2, .{});
+    defer wasm_file2.close();
+    const wasm = try wasm_file.readToEndAlloc(ga, std.math.maxInt(u64));
+    defer ga.free(wasm);
+    const wasm2 = try wasm_file2.readToEndAlloc(ga, std.math.maxInt(u64));
+    defer ga.free(wasm2);
+
+    const engine = try wasmtime.Engine.init();
+    defer engine.deinit();
+    std.debug.print("Engine initialized...\n", .{});
+
+    const module = try wasmtime.Module.initFromWat(engine, wasm);
+    defer module.deinit();
+
+    const module2 = try wasmtime.Module.initFromWat(engine, wasm2);
+    defer module2.deinit();
+
+    const store = try wasmtime.Store.init(engine);
+    defer store.deinit();
+    std.debug.print("Store initialized...\n", .{});
+
+    // intantiate wasi
+    const config = try wasmtime.c.WasiConfig.init();
+    config.inherit(.{});
+
+    var trap: ?*wasmtime.c.Trap = null;
+    const wasi = try wasmtime.c.WasiInstance.init(store, "wasi_snapshot_preview1", config, &trap);
+    if (trap) |t| {
+        std.debug.print("Unexpected trap during WasiInstance initialization\n", .{});
+        t.deinit();
+        return;
+    }
+    defer wasi.deinit();
+    std.debug.print("wasi instance initialized...\n", .{});
+
+    // create our linker and then add our WASI instance to it.
+    const linker = try wasmtime.c.Linker.init(store);
+    defer linker.deinit();
+    if (linker.defineWasi(wasi)) |err| {
+        var msg = err.getMessage();
+        defer msg.deinit();
+        std.debug.print("Linking init err: '{s}'\n", .{msg.toSlice()});
+        return;
+    }
+
+    // Instantiate `linking2` with our linker.
+    var linking2: ?*wasmtime.Instance = null;
+    const link_error2 = linker.instantiate(module2, &linking2, &trap);
+    if (trap) |t| {
+        std.debug.print("Unexpected trap during linker initialization\n", .{});
+        t.deinit();
+        return;
+    }
+    if (link_error2) |err| {
+        var msg = err.getMessage();
+        defer msg.deinit();
+        std.debug.print("Linker instantiate err: '{s}'\n", .{msg.toSlice()});
+        return;
+    }
+
+    // Register our new `linking2` instance with the linker
+    const name = wasmtime.c.NameVec.fromSlice("linking2");
+    if (linker.defineInstance(&name, linking2.?)) |err| {
+        var msg = err.getMessage();
+        defer msg.deinit();
+        std.debug.print("Define instance err: '{s}'\n", .{msg.toSlice()});
+        return;
+    }
+
+    var instance: ?*wasmtime.Instance = undefined;
+    if (linker.instantiate(module, &instance, &trap)) |err| {
+        var msg = err.getMessage();
+        defer msg.deinit();
+        std.debug.print("Instantiate err: '{s}'\n", .{msg.toSlice()});
+        return;
+    }
+    if (trap) |t| {
+        std.debug.print("Unexpected trap during linker initialization\n", .{});
+        t.deinit();
+        return;
+    }
+    defer instance.?.deinit();
+    std.debug.print("Instance initialized...\n", .{});
+    std.debug.print("Wasm linking completed...\n", .{});
+
+    if (instance.?.getExportFunc("run")) |f| {
+        std.debug.print("Calling export...\n", .{});
+        try f.call(void, .{});
+    } else {
+        std.debug.print("Export not found...\n", .{});
+    }
+}

src/c.zig

@@ -102,6 +102,15 @@ pub const ByteVec = extern struct {
     extern fn wasm_byte_vec_delete(ptr: *ByteVec) void;
 };
 
+pub const NameVec = extern struct {
+    size: usize,
+    data: [*]const u8,
+
+    pub fn fromSlice(slice: []const u8) NameVec {
+        return .{ .size = slice.len, .data = slice.ptr };
+    }
+};
+
 pub const ExternVec = extern struct {
     size: usize,
     data: [*]?*Extern,
@@ -284,11 +293,11 @@ pub const WasiInstance = opaque {
     }
 
     pub fn deinit(self: *WasiInstance) void {
-        was_instance_delete(self);
+        wasm_instance_delete(self);
     }
 
     extern fn wasi_instance_new(?*Store, [*:0]const u8, ?*WasiConfig, *?*Trap) ?*WasiInstance;
-    extern fn was_instance_delete(?*WasiInstance) void;
+    extern fn wasm_instance_delete(?*WasiInstance) void;
 };
 
 pub const Linker = opaque {
@@ -304,8 +313,8 @@ pub const Linker = opaque {
         return wasmtime_linker_define_wasi(self, wasi);
     }
 
-    pub fn defineInstance(self: *Linker, name: *const ByteVec, instance: *const Instance) ?*WasmError {
-        wasmtime_linker_define_instance(self, name, instance);
+    pub fn defineInstance(self: *Linker, name: *const NameVec, instance: *const Instance) ?*WasmError {
+        return wasmtime_linker_define_instance(self, name, instance);
     }
 
     pub fn instantiate(
@@ -320,7 +329,7 @@ pub const Linker = opaque {
     extern fn wasmtime_linker_new(?*Store) ?*Linker;
     extern fn wasmtime_linker_delete(?*Linker) void;
     extern fn wasmtime_linker_define_wasi(?*Linker, ?*const WasiInstance) ?*WasmError;
-    extern fn wasmtime_linker_define_instance(?*Linker, ?*const ByteVec, ?*const Instance) ?*WasmError;
+    extern fn wasmtime_linker_define_instance(?*Linker, ?*const NameVec, ?*const Instance) ?*WasmError;
     extern fn wasmtime_linker_instantiate(
         linker: ?*const Linker,
         module: ?*const Module,

src/main.zig

@@ -39,7 +39,7 @@ pub const Config = opaque {
         interruptable: bool = false,
     };
     pub fn init(options: Options) !*Config {
-        const config = wasm_config_new() orelse Error.ConfigInit;
+        const config = wasm_config_new() orelse return Error.ConfigInit;
         if (options.interruptable) {
             config.setInterruptable(true);
         }