@thi.ng/wasm-api 0.4.0 → 0.7.0

package/{zig/core.zig → include/wasmapi.zig}

@@ -1,51 +1,93 @@
 //! JavaScript externals for https://thi.ng/wasm-api
 
+const std = @import("std");
+const root = @import("root");
+
+/// Initialize the allocator to be exposed to the WASM host env
+/// (via `_wasm_allocate()` and `_wasm_free()`).
+/// If the user defines a public `WASM_ALLOCATOR` in their root file
+/// then this allocator will be used, otherwise the implementation
+/// falls back to using GPA.
+/// Note: The type for this var is purposefully chosen as an optional,
+/// effectively disabling allocations from the WASM host side if
+/// `WASM_ALLOCATOR` is set to null.
+pub const allocator: ?std.mem.Allocator = alloc: {
+    if (@hasDecl(root, "WASM_ALLOCATOR")) {
+        break :alloc root.WASM_ALLOCATOR;
+    } else {
+        var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+        break :alloc gpa.allocator();
+    }
+};
+
+/// Attempts to allocate memory using configured `allocator` and if
+/// successful returns address of new chunk or zero if failed
+/// Note: For SIMD compatibility all allocations are aligned to 16 bytes
+pub export fn _wasm_allocate(numBytes: usize) usize {
+    if (allocator) |alloc| {
+        var mem = alloc.alignedAlloc(u8, 16, numBytes) catch return 0;
+        return @ptrToInt(mem.ptr);
+    }
+    return 0;
+}
+
+/// Frees chunk of heap memory (previously allocated using `_wasm_allocate()`)
+/// starting at given address and of given byte length.
+/// Note: This is a no-op if the allocator is explicitly disabled (see `setAllocator()`),
+pub export fn _wasm_free(addr: usize, numBytes: usize) void {
+    if (allocator) |alloc| {
+        var mem = [2]usize{ addr, numBytes };
+        printFmt("{d}", .{@ptrCast(*[]u8, &mem).*});
+        alloc.free(@ptrCast(*[]u8, &mem).*);
+    }
+}
+
 /// Prints number using configured JS logger
-pub extern "core" fn printI8(x: i8) void;
+pub extern "wasmapi" fn printI8(x: i8) void;
 /// Prints number using configured JS logger
-pub extern "core" fn printU8(x: u8) void;
+pub extern "wasmapi" fn printU8(x: u8) void;
 /// Prints hex number using configured JS logger
-pub extern "core" fn printU8Hex(x: u8) void;
+pub extern "wasmapi" fn printU8Hex(x: u8) void;
 
 /// Prints number using configured JS logger
-pub extern "core" fn printI16(x: i16) void;
+pub extern "wasmapi" fn printI16(x: i16) void;
 /// Prints number using configured JS logger
-pub extern "core" fn printU16(x: u16) void;
+pub extern "wasmapi" fn printU16(x: u16) void;
 /// Prints hex number using configured JS logger
-pub extern "core" fn printU16Hex(x: u16) void;
+pub extern "wasmapi" fn printU16Hex(x: u16) void;
 
 /// Prints number using configured JS logger
-pub extern "core" fn printI32(x: i32) void;
+pub extern "wasmapi" fn printI32(x: i32) void;
 /// Prints number using configured JS logger
-pub extern "core" fn printU32(x: u32) void;
+pub extern "wasmapi" fn printU32(x: u32) void;
 /// Prints hex number using configured JS logger
-pub extern "core" fn printU32Hex(x: u32) void;
+pub extern "wasmapi" fn printU32Hex(x: u32) void;
 
 /// Prints decomposed i64 number using configured JS logger
-pub extern "core" fn _printI64(hi: i32, lo: i32) void;
+pub extern "wasmapi" fn _printI64(hi: i32, lo: i32) void;
 /// Convenience wrapper for _printI64(), accepting an i64
 pub fn printI64(x: i64) void {
     _printI64(@truncate(i32, x >> 32), @truncate(i32, x));
 }
 
 /// Prints decomposed u64 number using configured JS logger
-pub extern "core" fn _printU64(hi: u32, lo: u32) void;
+pub extern "wasmapi" fn _printU64(hi: u32, lo: u32) void;
 /// Convenience wrapper for _printU64(), accepting an u64
 pub fn printU64(x: u64) void {
     _printU64(@truncate(u32, x >> 32), @truncate(u32, x));
 }
 
 /// Prints decomposed u64 hex number using configured JS logger
-pub extern "core" fn _printU64Hex(hi: u32, lo: u32) void;
+pub extern "wasmapi" fn _printU64Hex(hi: u32, lo: u32) void;
 /// Convenience wrapper for _printU64Hex(), accepting an u64
 pub fn printU64Hex(x: u64) void {
     _printU64Hex(@truncate(u32, x >> 32), @truncate(u32, x));
 }
 
 /// Prints number using configured JS logger
-pub extern "core" fn printF32(x: f32) void;
+pub extern "wasmapi" fn printF32(x: f32) void;
 /// Prints number using configured JS logger
-pub extern "core" fn printF64(x: f64) void;
+pub extern "wasmapi" fn printF64(x: f64) void;
 
 /// Prints pointer as hex number using configured JS logger
 pub fn printPtr(ptr: *const anyopaque) void {
@@ -53,25 +95,25 @@ pub fn printPtr(ptr: *const anyopaque) void {
 }
 
 /// Prints number array using configured JS logger
-pub extern "core" fn _printI8Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI8Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printU8Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU8Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printI16Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI16Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printU16Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU16Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printI32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printU32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printI64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printI64Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printU64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printU64Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printF32Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printF32Array(addr: usize, len: usize) void;
 /// Prints number array using configured JS logger
-pub extern "core" fn _printF64Array(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printF64Array(addr: usize, len: usize) void;
 
 /// Prints number array using configured JS logger
 pub fn printI8Array(buf: []const i8) void {
@@ -115,10 +157,18 @@ pub fn printF64Array(buf: []const f64) void {
 }
 
 /// Prints a zero-terminated string using configured JS logger
-pub extern "core" fn _printStr0(addr: usize) void;
+pub extern "wasmapi" fn _printStr0(addr: usize) void;
 /// Prints a string of given length using configured JS logger
-pub extern "core" fn _printStr(addr: usize, len: usize) void;
+pub extern "wasmapi" fn _printStr(addr: usize, len: usize) void;
 /// Convenience wrapper for _printStr, accepting a slice as arg
 pub fn printStr(msg: []const u8) void {
     _printStr(@ptrToInt(msg.ptr), msg.len);
 }
+
+pub fn printFmt(comptime fmt: []const u8, args: anytype) void {
+    if (allocator) |alloc| {
+        const res = std.fmt.allocPrint(alloc, fmt, args) catch return;
+        defer alloc.free(res);
+        printStr(res);
+    }
+}

package/index.d.ts

@@ -1,4 +1,8 @@
 export * from "./api.js";
 export * from "./bridge.js";
+export * from "./codegen.js";
 export * from "./object-index.js";
+export * from "./codegen/typescript.js";
+export * from "./codegen/zig.js";
+export * from "./codegen/utils.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,3 +1,7 @@
 export * from "./api.js";
 export * from "./bridge.js";
+export * from "./codegen.js";
 export * from "./object-index.js";
+export * from "./codegen/typescript.js";
+export * from "./codegen/zig.js";
+export * from "./codegen/utils.js";

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@thi.ng/wasm-api",
-  "version": "0.4.0",
-  "description": "Modular, extensible API bridge and generic glue code between JS & WebAssembly",
+  "version": "0.7.0",
+  "description": "Generic, modular, extensible API bridge, glue code and bindings code generator for hybrid JS & WebAssembly projects",
   "type": "module",
   "module": "./index.js",
   "typings": "./index.d.ts",
+  "bin": "bin/wasm-api",
   "sideEffects": false,
   "repository": {
     "type": "git",
@@ -31,13 +32,20 @@
     "doc:readme": "yarn doc:stats && tools:readme",
     "doc:stats": "tools:module-stats",
     "pub": "yarn npm publish --access public",
-    "test": "testament test"
+    "test": "testament test",
+    "test:build-zig": "zig build-lib -O ReleaseSmall -target wasm32-freestanding -dynamic --strip --pkg-begin wasmapi include/wasmapi.zig --pkg-end test/custom.zig && wasm-dis -o custom.wast custom.wasm && cp custom.wasm test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.9",
+    "@thi.ng/api": "^8.4.0",
+    "@thi.ng/args": "^2.2.0",
+    "@thi.ng/binary": "^3.3.3",
+    "@thi.ng/checks": "^3.2.4",
+    "@thi.ng/compare": "^2.1.10",
+    "@thi.ng/defmulti": "^2.1.12",
     "@thi.ng/errors": "^2.1.10",
+    "@thi.ng/file-io": "^0.3.9",
     "@thi.ng/hex": "^2.1.9",
-    "@thi.ng/idgen": "^2.1.10",
+    "@thi.ng/idgen": "^2.1.11",
     "@thi.ng/logger": "^1.2.0"
   },
   "devDependencies": {
@@ -50,6 +58,9 @@
   },
   "keywords": [
     "api",
+    "bindings",
+    "c",
+    "codegen",
     "id",
     "logger",
     "memory",
@@ -72,7 +83,9 @@
   "files": [
     "*.js",
     "*.d.ts",
-    "*.zig"
+    "bin",
+    "include",
+    "codegen"
   ],
   "exports": {
     ".": {
@@ -84,6 +97,18 @@
     "./bridge": {
       "default": "./bridge.js"
     },
+    "./codegen": {
+      "default": "./codegen.js"
+    },
+    "./codegen/typescript": {
+      "default": "./codegen/typescript.js"
+    },
+    "./codegen/utils": {
+      "default": "./codegen/utils.js"
+    },
+    "./codegen/zig": {
+      "default": "./codegen/zig.js"
+    },
     "./object-index": {
       "default": "./object-index.js"
     }
@@ -92,5 +117,5 @@
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "0eeb5054111cea51f4714b013dda8700ade3cd54\n"
+  "gitHead": "78193cdd838d9d09114352b117b6c5e92631e3cd\n"
 }

package/dev/custom.zig

@@ -1,12 +0,0 @@
-// Import JS core API
-const js = @import("wasmapi");
-
-/// Fill vec2 with random values
-extern fn custom_randomVec2(addr: usize) void;
-
-export fn test_random_vec2() void {
-    var foo = [2]f32{ 0, 0 };
-    js.printF32Array(foo[0..]);
-    custom_randomVec2(@ptrToInt(&foo));
-    js.printF32Array(foo[0..]);
-}

package/dev/fieldinfo.zig

@@ -1,135 +0,0 @@
-const js = @import("wasmapi");
-const std = @import("std");
-
-const Foo = struct {
-    pos: [2]f32,
-    col: [3]f32,
-    speed: u8,
-    acc: u16,
-};
-
-fn writeU32(buf: [*]u8, i: u32, x: u32) void {
-    buf[i] = @intCast(u8, x & 0xff);
-    buf[i + 1] = @intCast(u8, x >> 8 & 0xff);
-    buf[i + 2] = @intCast(u8, x >> 16 & 0xff);
-    buf[i + 3] = @intCast(u8, x >> 24);
-}
-
-const FieldType = enum(u8) {
-    I8,
-    U8,
-    I16,
-    U16,
-    I32,
-    U32,
-    F32,
-    F64,
-
-    pub fn fromTypeInfo(comptime info: std.builtin.TypeInfo) FieldType {
-        if (info == .Int) {
-            const bits = info.Int.bits;
-            if (!(bits == 8 or bits == 16 or bits == 32)) {
-                @compileError("unsupported int type (only 8, 16, 32)");
-            }
-            if (info.Int.signedness == .signed) {
-                return switch (bits) {
-                    8 => .I8,
-                    16 => .I16,
-                    32 => .I32,
-                    else => unreachable,
-                };
-            } else {
-                return switch (bits) {
-                    8 => .U8,
-                    16 => .U16,
-                    32 => .U32,
-                    else => unreachable,
-                };
-            }
-        } else if (info == .Float) {
-            return switch (info.Float.bits) {
-                32 => .F32,
-                64 => .F64,
-                else => @compileError("unsupported float type (only f32, f64)"),
-            };
-        }
-        @compileError("unsupported field type");
-    }
-};
-
-// int
-// float
-// ptr
-// array
-// slice
-
-// 8
-// 16
-// 32
-// 64
-
-const Field = packed struct {
-    name: [15]u8 = [_]u8{0} ** 15,
-    tag: FieldType = .U8,
-    offset: u32,
-    len: u32 = 0,
-
-    pub fn fromTypeInfo(comptime T: type, comptime field: std.builtin.TypeInfo.StructField) Field {
-        const finfo = @typeInfo(field.field_type);
-        var ftype: FieldType = .U8;
-        var flen = 0;
-        if (!(finfo == .Int or finfo == .Float or finfo == .Array)) {
-            @compileError("unsupported field type: " ++ @typeName(field.field_type));
-        }
-        if (finfo == .Array) {
-            const cinfo = @typeInfo(finfo.Array.child);
-            if (!(cinfo == .Int or cinfo == .Float)) {
-                @compileError("unsupported field array type: " ++ @typeName(field.field_type));
-            }
-            ftype = FieldType.fromTypeInfo(cinfo);
-            flen = finfo.Array.len;
-        } else {
-            ftype = FieldType.fromTypeInfo(finfo);
-        }
-        var res: Field = .{
-            .tag = ftype,
-            .offset = @offsetOf(T, field.name),
-            .len = flen,
-        };
-        const len = @minimum(14, field.name.len);
-        std.mem.copy(u8, res.name[0..len], field.name[0..len]);
-        return res;
-    }
-};
-
-fn writeTypeInfo(comptime T: type) []u8 {
-    const fields = @typeInfo(T).Struct.fields;
-    const fsize = @sizeOf(Field);
-    var buf: [fields.len * fsize + 4]u8 = undefined;
-    var i = 4;
-    writeU32(&buf, 0, fields.len);
-    for (fields) |field| {
-        var f = Field.fromTypeInfo(T, field);
-        std.mem.copy(
-            u8,
-            buf[i .. i + fsize],
-            @ptrCast(*[fsize]u8, &f)[0..],
-        );
-        i += fsize;
-    }
-    return buf[0..];
-}
-
-export var Foo__info = writeTypeInfo(Foo);
-export var Bar__info = writeTypeInfo(struct { x: i16, y: i16 });
-
-export var U64: u64 = 0xdecafbadcafebabe;
-export var I64: i64 = -0x8000000000000000;
-
-export fn foo() void {
-    js.printI64(I64);
-    js.printU64(U64);
-    js.printI64Array(&[_]i64{ I64, I64 });
-    js.printU32(@truncate(u32, U64 >> 32));
-    js.printU32Hex(@truncate(u32, U64 >> 32));
-}

package/dev/hello.zig

@@ -1,9 +0,0 @@
-//! Example Zig application (hello.zig)
-
-/// import externals
-/// see build command for configuration
-const js = @import("wasmapi");
-
-export fn start() void {
-    js.printStr("hello world!");
-}

package/dev/zig-cache/o/0fd683610fe16c12563bf410950c8193/builtin.zig

@@ -1,39 +0,0 @@
-const std = @import("std");
-/// Zig version. When writing code that supports multiple versions of Zig, prefer
-/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
-pub const zig_version = std.SemanticVersion.parse("0.10.0-dev.3034+6fab6c3e4") catch unreachable;
-pub const zig_backend = std.builtin.CompilerBackend.stage1;
-/// Temporary until self-hosted supports the `cpu.arch` value.
-pub const stage2_arch: std.Target.Cpu.Arch = .wasm32;
-
-pub const output_mode = std.builtin.OutputMode.Lib;
-pub const link_mode = std.builtin.LinkMode.Dynamic;
-pub const is_test = false;
-pub const single_threaded = true;
-pub const abi = std.Target.Abi.musl;
-pub const cpu: std.Target.Cpu = .{
-    .arch = .wasm32,
-    .model = &std.Target.wasm.cpu.generic,
-    .features = std.Target.wasm.featureSet(&[_]std.Target.wasm.Feature{
-    }),
-};
-pub const os = std.Target.Os{
-    .tag = .freestanding,
-    .version_range = .{ .none = {} },
-};
-pub const target = std.Target{
-    .cpu = cpu,
-    .os = os,
-    .abi = abi,
-};
-pub const object_format = std.Target.ObjectFormat.wasm;
-pub const mode = std.builtin.Mode.ReleaseSmall;
-pub const link_libc = false;
-pub const link_libcpp = false;
-pub const have_error_return_tracing = false;
-pub const valgrind_support = false;
-pub const sanitize_thread = false;
-pub const position_independent_code = true;
-pub const position_independent_executable = false;
-pub const strip_debug_info = true;
-pub const code_model = std.builtin.CodeModel.default;

package/test/custom.zig

@@ -1,12 +0,0 @@
-// Import JS core API
-const js = @import("wasmapi");
-
-/// Fill vec2 with random values
-extern "custom" fn setVec2(addr: usize) void;
-
-export fn test_setVec2() void {
-    var foo = [2]f32{ 0, 0 };
-    js.printF32Array(foo[0..]);
-    setVec2(@ptrToInt(&foo));
-    js.printF32Array(foo[0..]);
-}