function exporting and callbacks

Author: scottredig

example/main.zig

@@ -135,11 +135,30 @@ export fn main() void {
 
     logStr("\n============================= Handle vs ConstHandle =============================");
     {
-        logStr("zjb.global and zjb.constString add their ConstHandle on first use, and rember for subsiquent uses.  They can't be released.");
+        logStr("zjb.global and zjb.constString add their ConstHandle on first use, and remember for subsiquent uses.  They can't be released.");
         logStr("While zjb.string and Handle return values must be released after being used or they'll leak.");
         logStr("See that some string remain in handles, while others have been removed after use.");
         const handles = zjb.global("zjb").get("_handles", zjb.Handle);
         defer handles.release();
         log(handles);
     }
+
+    logStr("\n============================= Exporting functions (press a key for a callback) =============================");
+    zjb.global("document").call("addEventListener", .{ zjb.constString("keydown"), zjb.fnHandle("keydownCallback", keydownCallback) }, void);
+}
+
+fn keydownCallback(event: zjb.Handle) callconv(.C) void {
+    defer event.release();
+
+    zjb.global("console").call("log", .{ zjb.constString("From keydown callback, event:"), event }, void);
+}
+
+var value: i32 = 0;
+fn incrementAndGet(increment: i32) callconv(.C) i32 {
+    value += increment;
+    return value;
+}
+
+comptime {
+    zjb.exportFn("incrementAndGet", incrementAndGet);
 }

example/static/script.js

@@ -9,5 +9,8 @@ var zjb = new Zjb();
 	WebAssembly.instantiateStreaming(fetch("example.wasm"), {env: env, zjb: zjb.imports}).then(function (results) {
 		zjb.instance = results.instance;
 		results.instance.exports.main();
+		console.log("calling zjb exports from javascript", zjb.exports.incrementAndGet(1));
+		console.log("calling zjb exports from javascript", zjb.exports.incrementAndGet(1));
+		console.log("calling zjb exports from javascript", zjb.exports.incrementAndGet(1));
 	});
 })();

example/static/style.css

@@ -2,5 +2,5 @@ html, body {
 	margin: 0px;
 	width: 100%;
 	height: 100%;
-	//background-color: #111;
+	background-color: #111;
 }

src/generate_js.zig

@@ -11,8 +11,10 @@ pub fn main() !void {
         return ExtractError.BadArguments;
     }
 
-    var funcs = std.ArrayList([]const u8).init(alloc);
-    defer funcs.deinit();
+    var imports = std.ArrayList([]const u8).init(alloc);
+    defer imports.deinit();
+    var exports = std.ArrayList([]const u8).init(alloc);
+    defer exports.deinit();
 
     {
         var file = try std.fs.openFileAbsolute(args[3], .{});
@@ -54,7 +56,21 @@ pub fn main() !void {
                         if (desc_type != 0) { // Not a function?
                             return ExtractError.ImportTypeNotSupported;
                         }
-                        try funcs.append(try alloc.dupe(u8, name));
+                        try imports.append(try alloc.dupe(u8, name));
+                    }
+                }
+            } else if (section_id == 7) {
+                const export_count = try r.getU32();
+                for (0..export_count) |_| {
+                    const name_length = try r.getU32();
+                    const name = try r.bytes(name_length);
+
+                    const desc_type = try r.byte();
+                    const desc_index = try r.getU32();
+                    _ = desc_index;
+
+                    if (desc_type == 0 and std.mem.startsWith(u8, name, "zjb_fn")) {
+                        try exports.append(try alloc.dupe(u8, name));
                     }
                 }
             } else {
@@ -63,7 +79,8 @@ pub fn main() !void {
         }
     }
 
-    std.sort.insertion([]const u8, funcs.items, {}, strBefore);
+    std.sort.insertion([]const u8, imports.items, {}, strBefore);
+    std.sort.insertion([]const u8, exports.items, {}, strBefore);
 
     var out_file = try std.fs.createFileAbsolute(args[1], .{});
     defer out_file.close();
@@ -84,11 +101,6 @@ pub fn main() !void {
         \\  }
         \\  constructor() {
         \\    this._decoder = new TextDecoder();
-        \\    this._handles = new Map();
-        \\    this._handles.set(0, null);
-        \\    this._handles.set(1, window);
-        \\    this._handles.set(2, "");
-        \\    this._next_handle = 3;
         \\    this.imports = {
         \\
     );
@@ -97,7 +109,7 @@ pub fn main() !void {
     var func_args = std.ArrayList(ArgType).init(alloc);
     defer func_args.deinit();
 
-    implement_functions: for (funcs.items) |func| {
+    implement_functions: for (imports.items) |func| {
         if (std.mem.eql(u8, lastFunc, func)) {
             continue;
         }
@@ -256,10 +268,119 @@ pub fn main() !void {
 
         try writer.writeAll(";\n      },\n");
     }
+    try writer.writeAll("    };\n"); // end imports
+
+    try writer.writeAll("    this.exports = {\n");
+
+    var export_names = std.ArrayList([]const u8).init(alloc);
+    defer export_names.deinit();
+
+    for (exports.items) |func| {
+        func_args.clearRetainingCapacity();
+
+        var np = NameParser{ .slice = func };
+        try np.must("zjb_fn_");
+
+        while (!(np.maybe("_") or np.slice.len == 0)) {
+            try func_args.append(try np.mustType());
+        }
+
+        const ret_type = try np.mustType();
+        try np.must("_");
+
+        const name = np.slice;
+        try export_names.append(name);
+
+        //////////////////////////////////
+
+        try writer.writeAll("      \"");
+        try writer.writeAll(name);
+        try writer.writeAll("\": (");
+
+        for (0..func_args.items.len) |i| {
+            if (i > 0) {
+                try writer.writeAll(", ");
+            }
+            try writer.print("arg{d}", .{i});
+        }
+
+        try writer.writeAll(") => {\n        ");
+        switch (ret_type) {
+            .void => {},
+            .bool => {
+                try writer.writeAll("return Boolean(");
+            },
+            .object => {
+                try writer.writeAll("return this._handles.get(");
+            },
+            .number => {
+                try writer.writeAll("return ");
+            },
+        }
+
+        try writer.writeAll("this.instance.exports.");
+        try writer.writeAll(func);
+        try writer.writeAll("(");
+
+        for (func_args.items, 0..) |arg, i| {
+            if (i > 0) {
+                try writer.writeAll(", ");
+            }
+            switch (arg) {
+                .void => {
+                    return ExtractError.InvalidExportedName;
+                },
+                .bool => {
+                    try writer.print("Boolean(arg{d})", .{i});
+                },
+                .object => {
+                    try writer.print("this.new_handle(arg{d})", .{i});
+                },
+                .number => {
+                    try writer.print("arg{d}", .{i});
+                },
+            }
+        }
+
+        try writer.writeAll(")");
+
+        switch (ret_type) {
+            .bool, .object => {
+                try writer.writeAll(")");
+            },
+            .void, .number => {},
+        }
+        try writer.writeAll(";\n      },\n");
+    }
+    try writer.writeAll("    };\n"); // end exports
+
+    try writer.writeAll(
+        \\    this._export_reverse_handles = {};
+        \\    this._handles = new Map();
+        \\    this._handles.set(0, null);
+        \\    this._handles.set(1, window);
+        \\    this._handles.set(2, "");
+        \\    this._handles.set(3, this.exports);
+        \\    this._next_handle = 4;
+        \\
+    );
+
+    try writer.writeAll(
+        \\  }
+        \\};
+        \\
+    );
+
+    std.sort.insertion([]const u8, export_names.items, {}, strBefore);
+    if (export_names.items.len > 1) {
+        for (0..export_names.items.len - 1) |i| {
+            if (std.mem.eql(u8, export_names.items[i], export_names.items[i + 1])) {
+                std.debug.print("ERROR: function export name used twice: {s}.\n", .{export_names.items[i]});
+                std.posix.exit(1);
+            }
+        }
+    }
 
-    try writer.writeAll("    };\n");
-    try writer.writeAll("  }\n");
-    try writer.writeAll("};\n");
     try out_file.sync();
 }
 

src/zjb.zig

@@ -33,6 +33,32 @@ pub fn global(comptime b: []const u8) ConstHandle {
     }.get();
 }
 
+pub fn fnHandle(comptime name: []const u8, comptime f: anytype) ConstHandle {
+    comptime exportFn(name, f);
+
+    return struct {
+        var handle: ?ConstHandle = null;
+        fn get() ConstHandle {
+            if (handle) |h| {
+                return h;
+            }
+            handle = @enumFromInt(@intFromEnum(ConstHandle.exports.get(name, Handle)));
+            return handle.?;
+        }
+    }.get();
+}
+
+pub fn exportFn(comptime name: []const u8, comptime f: anytype) void {
+    comptime var export_name: []const u8 = "zjb_fn_";
+    const type_info = @typeInfo(@TypeOf(f)).Fn;
+    inline for (type_info.params) |param| {
+        export_name = export_name ++ comptime shortTypeName(param.type orelse @compileError("zjb exported functions need specified types."));
+    }
+    export_name = export_name ++ "_" ++ comptime shortTypeName(type_info.return_type orelse null) ++ "_" ++ name;
+
+    @export(f, .{ .name = export_name });
+}
+
 pub fn i8ArrayView(data: []const i8) Handle {
     return zjb.i8ArrayView(data.ptr, data.len);
 }
@@ -88,6 +114,7 @@ pub const ConstHandle = enum(i32) {
     null = 0,
     global = 1,
     empty_string = 2,
+    exports = 3,
     _,
 
     pub fn isNull(handle: ConstHandle) bool {
@@ -216,7 +243,7 @@ fn shortTypeName(comptime T: type) []const u8 {
         // in javascript so there's no reason not to do it.
         i32, i64, f32, f64, comptime_int, comptime_float => "n",
         else => {
-            @compileError("unexpected type" ++ @typeName(T));
+            @compileError("unexpected type " ++ @typeName(T) ++ ". Supported types: zjb.Handle, bool, i32, i64, f32, f64, comptime_int, copmtime_float, void (as return type).");
         },
     };
 }