More helpers (#202)

# Description

Rename `addHostFunction` to `exposeHostFunction` and add similar
functions for globals, tables, etc.

Author: malcolmstill

src/store.zig

@@ -10,6 +10,7 @@ const Elem = @import("store/elem.zig").Elem;
 const Data = @import("store/data.zig").Data;
 const Import = @import("module.zig").Import;
 const Tag = @import("module.zig").Tag;
+const Mutability = @import("module.zig").Mutability;
 const RefType = @import("valtype.zig").RefType;
 const ValType = @import("valtype.zig").ValType;
 const Instance = @import("instance.zig").Instance;
@@ -103,6 +104,8 @@ pub const ArrayListStore = struct {
         });
     }
 
+ /// Given a funcaddr return a Function if the funcaddr exists
+ /// otherwise error with BadFunctionIndex.
  pub fn function(self: *ArrayListStore, funcaddr: usize) !Function {
  if (funcaddr >= self.functions.items.len) return error.BadFunctionIndex;
  return self.functions.items[funcaddr];
@@ -114,33 +117,23 @@ pub const ArrayListStore = struct {
  return self.functions.items.len - 1;
     }
 
- // Helper function for adding a host function
- pub fn addHostFunction(self: *ArrayListStore, module: []const u8, function_name: []const u8, host_function_pointer: anytype, params: []const ValType, results: []const ValType) !void {
- const handle = try self.addFunction(Function{
-            .params = params,
-            .results = results,
-            .subtype = .{
-                .host_function = .{
-                    .func = host_function_pointer,
-                },
-            },
-        });
-
- try self.@"export"(module[0..], function_name[0..], .Func, handle);
-    }
-
+ /// Given a memaddr return a pointer to the Memory if the memaddr exists
+ /// otherwise error with BadMemoryIndex.
  pub fn memory(self: *ArrayListStore, memaddr: usize) !*Memory {
  if (memaddr >= self.memories.items.len) return error.BadMemoryIndex;
  return &self.memories.items[memaddr];
     }
 
+ /// Allocate a new Memory with min / max size and add to store.
  pub fn addMemory(self: *ArrayListStore, min: u32, max: ?u32) !usize {
  const mem_ptr = try self.memories.addOne();
  mem_ptr.* = Memory.init(self.alloc, min, max);
  _ = try mem_ptr.grow(min);
  return self.memories.items.len - 1;
     }
 
+ /// Given a tableaddr return a pointer to the Table if the tableaddr exists
+ /// otherwise error with BadTableIndex.
  pub fn table(self: *ArrayListStore, tableaddr: usize) !*Table {
  if (tableaddr >= self.tables.items.len) return error.BadTableIndex;
  return &self.tables.items[tableaddr];
@@ -152,18 +145,23 @@ pub const ArrayListStore = struct {
  return self.tables.items.len - 1;
     }
 
+ /// Given a globaladdr return a pointer to the Global if the globaladdr exists
+ /// otherwise error with BadGlobalIndex.
  pub fn global(self: *ArrayListStore, globaladdr: usize) !*Global {
  if (globaladdr >= self.globals.items.len) return error.BadGlobalIndex;
  return &self.globals.items[globaladdr];
     }
 
+ /// Add a Global to the store and return its globaladdr
  pub fn addGlobal(self: *ArrayListStore, value: Global) !usize {
  const glbl_ptr = try self.globals.addOne();
  glbl_ptr.* = value;
 
  return self.globals.items.len - 1;
     }
 
+ /// Given a elemaddr return a pointer to the Elem if the elemaddr exists
+ /// otherwise error with BadElemAddr.
  pub fn elem(self: *ArrayListStore, elemaddr: usize) !*Elem {
  if (elemaddr >= self.elems.items.len) return error.BadElemAddr;
  return &self.elems.items[elemaddr];
@@ -175,6 +173,8 @@ pub const ArrayListStore = struct {
  return self.elems.items.len - 1;
     }
 
+ /// Given a dataaddr return a pointer to the Data if the dataaddr exists
+ /// otherwise error with BadDataAddr.
  pub fn data(self: *ArrayListStore, dataaddr: usize) !*Data {
  if (dataaddr >= self.datas.items.len) return error.BadDataAddr;
  return &self.datas.items[dataaddr];
@@ -185,4 +185,54 @@ pub const ArrayListStore = struct {
  data_ptr.* = try Data.init(self.alloc, count);
  return self.datas.items.len - 1;
     }
+
+ // Helper functions for exposing values
+
+ pub fn exposeHostFunction(self: *ArrayListStore, module: []const u8, function_name: []const u8, host_function_pointer: anytype, params: []const ValType, results: []const ValType) !void {
+ const funcaddr = try self.addFunction(Function{
+            .params = params,
+            .results = results,
+            .subtype = .{
+                .host_function = .{
+                    .func = host_function_pointer,
+                },
+            },
+        });
+
+ try self.@"export"(module[0..], function_name[0..], .Func, funcaddr);
+    }
+
+ pub fn exposeMemory(self: *ArrayListStore, module: []const u8, name: []const u8, min: u32, max: ?u32) !void {
+ const memaddr = try self.addMemory(min, max);
+
+ try self.@"export"(module, name, .Mem, memaddr);
+    }
+
+ pub fn exposeTable(self: *ArrayListStore, module: []const u8, name: []const u8, reftype: RefType, entries: u32, max: ?u32) !void {
+ const tableaddr = try self.addTable(reftype, entries, max);
+
+ try self.@"export"(module, name, .Table, tableaddr);
+    }
+
+ pub fn exposeGlobal(self: *ArrayListStore, module: []const u8, name: []const u8, value: u64, valtype: ValType, mutability: Mutability) !void {
+ const globaladdr = try self.addGlobal(.{
+            .value = value,
+            .valtype = valtype,
+            .mutability = mutability,
+        });
+
+ try self.@"export"(module, name, .Global, globaladdr);
+    }
+
+ pub fn exposeElem(self: *ArrayListStore, module: []const u8, name: []const u8, reftype: RefType, count: u32) !void {
+ const elemaddr = try self.addElem(reftype, count);
+
+ try self.@"export"(module, name, .Elem, elemaddr);
+    }
+
+ pub fn exposeData(self: *ArrayListStore, module: []const u8, name: []const u8, count: u32) !void {
+ const dataaddr = try self.addData(count);
+
+ try self.@"export"(module, name, .Data, dataaddr);
+    }
 };

test/generate_interface/README.md

@@ -1,3 +1,3 @@
 # generate_interface
 
-Provide `generate_interface` with a `.wasm` and it will print out host function stubs and `addHostFunction` code for the interfacing with that `.wasm` binary.
+Provide `generate_interface` with a `.wasm` and it will print out host function stubs and `exposeHostFunction` code for the interfacing with that `.wasm` binary.

test/generate_interface/src/generate_interface.zig

@@ -42,7 +42,7 @@ pub fn main() !void {
 
  const function_type = module.types.list.items[function.typeidx];
 
- try stdout.print("\ttry store.addHostFunction(\"{s}\", \"{s}\", {s}, &[_]zware.ValType{{", .{function_import.module, function_import.name, function_import.name});
+ try stdout.print("\ttry store.exposeHostFunction(\"{s}\", \"{s}\", {s}, &[_]zware.ValType{{", .{function_import.module, function_import.name, function_import.name});
  for (function_type.params, 0..) |param, i| {
  try stdout.print(".{s}", .{@tagName(param)});
 

test/testrunner/src/testrunner.zig

@@ -97,61 +97,28 @@ pub fn main() anyerror!void {
 
  // Initialise a store
  var store: Store = Store.init(alloc);
- const spectest_module = "spectest";
+ const spectest = "spectest";
 
  // Init spectest memory
- const mem_handle = try store.addMemory(1, 2);
- _ = try store.memory(mem_handle);
-
- const spectest_memory_name = "memory";
- try store.@"export"(spectest_module[0..], spectest_memory_name[0..], .Mem, mem_handle);
-
- // Init spec test table
- const table_handle = try store.addTable(.FuncRef, 10, 20);
- const spectest_table_name = "table";
-
- try store.@"export"(spectest_module[0..], spectest_table_name[0..], .Table, table_handle);
-
- // Initiliase spectest globals
- const i32_handle = try store.addGlobal(Global{
-        .value = 666,
-        .valtype = .I32,
-        .mutability = .Immutable,
-    });
- const i32_name = "global_i32";
- try store.@"export"(spectest_module[0..], i32_name[0..], .Global, i32_handle);
-
- const i64_handle = try store.addGlobal(Global{
-        .value = 666,
-        .valtype = .I64,
-        .mutability = .Immutable,
-    });
- const i64_name = "global_i64";
- try store.@"export"(spectest_module[0..], i64_name[0..], .Global, i64_handle);
-
- const f32_handle = try store.addGlobal(Global{
-        .value = 666,
-        .valtype = .F32,
-        .mutability = .Immutable,
-    });
- const f32_name = "global_f32";
- try store.@"export"(spectest_module[0..], f32_name[0..], .Global, f32_handle);
-
- const f64_handle = try store.addGlobal(Global{
-        .value = 666,
-        .valtype = .F64,
-        .mutability = .Immutable,
-    });
- const f64_name = "global_f64";
- try store.@"export"(spectest_module[0..], f64_name[0..], .Global, f64_handle);
-
- try store.addHostFunction(spectest_module[0..], "print", print, &[_]ValType{}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_i32", print_i32, &[_]ValType{.I32}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_i64", print_i64, &[_]ValType{.I64}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_f32", print_f32, &[_]ValType{.F32}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_f64", print_f64, &[_]ValType{.F64}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_i32_f32", print_i32_f32, &[_]ValType{.I32, .F32}, &[_]ValType{});
- try store.addHostFunction(spectest_module[0..], "print_f64_f64", print_f64_f64, &[_]ValType{.F64, .F64}, &[_]ValType{});
+ try store.exposeMemory(spectest, "memory", 1, 2);
+
+ // Init spectest table
+ try store.exposeTable(spectest, "table", .FuncRef, 10, 20);
+
+ // Expose spectest globals
+ try store.exposeGlobal(spectest, "global_i32", 666, .I32, .Immutable);
+ try store.exposeGlobal(spectest, "global_i64", 666, .I64, .Immutable);
+ try store.exposeGlobal(spectest, "global_f32", 666, .F32, .Immutable);
+ try store.exposeGlobal(spectest, "global_f64", 666, .F64, .Immutable);
+
+ // Expose host functions
+ try store.exposeHostFunction(spectest, "print", print, &[_]ValType{}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_i32", print_i32, &[_]ValType{.I32}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_i64", print_i64, &[_]ValType{.I64}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_f32", print_f32, &[_]ValType{.F32}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_f64", print_f64, &[_]ValType{.F64}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_i32_f32", print_i32_f32, &[_]ValType{.I32, .F32}, &[_]ValType{});
+ try store.exposeHostFunction(spectest, "print_f64_f64", print_f64_f64, &[_]ValType{.F64, .F64}, &[_]ValType{});
 
  var current_instance: *Instance = undefined;
  var registered_names = StringHashMap(*Instance).init(alloc);