diff options
Diffstat (limited to 'src/zilch/Env')
| -rw-r--r-- | src/zilch/Env/call.zig | 16 | ||||
| -rw-r--r-- | src/zilch/Env/future.zig | 59 | ||||
| -rw-r--r-- | src/zilch/Env/js.zig | 22 | ||||
| -rw-r--r-- | src/zilch/Env/root.zig | 162 | ||||
| -rw-r--r-- | src/zilch/Env/value.zig | 115 |
5 files changed, 374 insertions, 0 deletions
diff --git a/src/zilch/Env/call.zig b/src/zilch/Env/call.zig new file mode 100644 index 0000000..a5db835 --- /dev/null +++ b/src/zilch/Env/call.zig @@ -0,0 +1,16 @@ + +pub const Call = extern struct { + kind: Kind, + num_args: u8, + + const Kind = enum(u8) { + free = 0, + get_prop = 1, + set_prop = 2, + del_prop = 3, + call_method = 4, + call = 5, + new = 6, + }; +}; + diff --git a/src/zilch/Env/future.zig b/src/zilch/Env/future.zig new file mode 100644 index 0000000..a014990 --- /dev/null +++ b/src/zilch/Env/future.zig @@ -0,0 +1,59 @@ +const std = @import("std"); +const Env = @import("root.zig"); +const z = @import("../root.zig"); + + +pub fn Future(comptime kind: Env.Value.Kind) type { + return struct { + const Self = @This(); + + future: AnyFuture, + + pub fn fromAny(future: AnyFuture) Self { + return .{ .future = future }; + } + + pub fn await(self: *const Self, env: *Env) !kind.asType() { + return self.future.await(env, kind); + } + }; +} + +pub const AnyFuture = union(enum) { + const Self = @This(); + + result: *Env.Value, + err: anyerror, + + pub fn await(self: *const Self, env: *Env, comptime kind: Env.Value.Kind) !kind.asType() { + const result = try self.awaitAny(env); + + if (kind != result.kind) { + std.log.err("unexpected {}, expected {}", .{ result.kind, kind }); + @panic("type error"); + } + + return switch (kind) { + .uninit => @panic("uninitialized result"), + .string => result.value.string.ptr[0..result.value.string.len], + else => @field(result.value, @tagName(kind)), + }; + } + + pub fn awaitAny(self: *const Self, env: *Env) !Env.Value { + switch (self.*) { + .err => |err| return err, + .result => |result| { + defer env.pool.destroy(result); + + if (result.kind != .uninit) { + return result.*; + } + + env.flush(); + + return result.*; + } + } + } +}; diff --git a/src/zilch/Env/js.zig b/src/zilch/Env/js.zig new file mode 100644 index 0000000..c1ff85d --- /dev/null +++ b/src/zilch/Env/js.zig @@ -0,0 +1,22 @@ +const std = @import("std"); +const Env = @import("root.zig"); + +pub extern "object_store" fn process( + [*]const Env.Call, + [*]const Env.Value, + [*]*Env.Value, + length: usize, +) void; + +export fn valueAllocString(value: *Env.Value, len: usize) [*]u8 { + const ptr: [*]u8 = @ptrCast(std.heap.wasm_allocator.alloc(u8, len) catch @panic("unable to allocate string")); + value.kind = .string; + value.value = .{ + .string = .{ + .ptr = ptr, + .len = len, + }, + }; + + return @constCast(value.value.string.ptr); +} diff --git a/src/zilch/Env/root.zig b/src/zilch/Env/root.zig new file mode 100644 index 0000000..6fd2bab --- /dev/null +++ b/src/zilch/Env/root.zig @@ -0,0 +1,162 @@ +const std = @import("std"); + +const Self = @This(); + +const js = @import("js.zig"); +const future = @import("future.zig"); +const Object = @import("../Object.zig"); + +pub const Call = @import("call.zig").Call; +pub const AnyFuture = future.AnyFuture; +pub const Future = future.Future; +pub const Value = @import("value.zig").Value; + +calls: std.ArrayList(Call) = .empty, +values: std.ArrayList(Value) = .empty, +pool: std.heap.MemoryPool(Value) = .empty, +results: std.ArrayList(*Value) = .empty, +gpa: std.mem.Allocator, + +pub const default: Self = .{ .gpa = std.heap.wasm_allocator }; + +pub fn init(gpa: std.mem.Allocator) Self { + return .{ .gpa = gpa }; +} + +pub fn getProp(self: *Self, object: *Object, key: anytype) AnyFuture { + self.calls.append(self.gpa, .{ + .kind = .get_prop, + .num_args = 2, + }) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(key)) catch |err| return .{ .err = err }; + + return self.registerFuture() catch |err| .{ .err = err }; +} + +pub fn setProp( + self: *Self, + object: *Object, + key: anytype, + value: anytype, +) Future(.undefined) { + self.calls.append(self.gpa, .{ + .kind = .set_prop, + .num_args = 3, + }) catch |err| return .fromAny(.{ .err = err }); + + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(key)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(value)) catch |err| return .fromAny(.{ .err = err }); + + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); +} + +pub fn deleteProp( + self: *Self, + object: *Object, + key: anytype, +) Future(.undefined) { + self.calls.append(self.gpa, .{ + .kind = .del_prop, + .num_args = 2, + }) catch |err| return .fromAny(.{ .err = err }); + + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + self.values.append(self.gpa, .from(key)) catch |err| return .fromAny(.{ .err = err }); + + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); +} + +pub fn callMethod( + self: *Self, + object: *Object, + key: []const u8, + args: anytype, +) AnyFuture { + self.calls.append(self.gpa, .{ + .kind = .call_method, + .num_args = 2 + args.len, + }) catch |err| return .{ .err = err }; + + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; + self.values.append(self.gpa, .from(key)) catch |err| return .{ .err = err }; + + inline for (args) |arg| { + self.values.append(self.gpa, .from(arg)) catch |err| return .{ .err = err }; + } + + return self.registerFuture() catch |err| return .{ .err = err }; +} + +pub fn call(self: *Self, object: *Object, args: anytype) AnyFuture { + self.calls.append(self.gpa, .{ + .kind = .call, + .num_args = 1 + args.len, + }) catch |err| return .{ .err = err }; + + self.values.append(self.gpa, .from(object)) catch |err| return .{ .err = err }; + + inline for (args) |arg| { + self.values.append(self.gpa, .from(arg)) catch |err| return .{ .err = err }; + } + + return self.registerFuture() catch |err| return .{ .err = err }; +} + +pub fn free(self: *Self, object: *Object) Future(.undefined) { + self.calls.append(self.gpa, .{ + .kind = .free, + .num_args = 1, + }) catch |err| return .fromAny(.{ .err = err }); + + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); +} + +pub fn new(self: *Self, object: *Object, args: anytype) Future(.object) { + self.calls.append(self.gpa, .{ + .kind = .new, + .num_args = 1 + args.len, + }) catch |err| return .fromAny(.{ .err = err }); + + self.values.append(self.gpa, .from(object)) catch |err| return .fromAny(.{ .err = err }); + + inline for (args) |arg| { + self.values.append(self.gpa, .from(arg)) catch |err| return .fromAny(.{ .err = err }); + } + + return .fromAny(self.registerFuture() catch |err| .{ .err = err }); +} + +fn registerFuture(self: *Self) !AnyFuture { + const result = try self.pool.create(self.gpa); + errdefer self.pool.destroy(result); + result.kind = .uninit; + try self.results.append(self.gpa, result); + return .{ .result = result }; +} + +pub fn flush(self: *Self) void { + js.process( + @ptrCast(self.calls.items), + @ptrCast(self.values.items), + @ptrCast(self.results.items), + self.results.items.len, + ); + self.calls.clearRetainingCapacity(); + self.values.clearRetainingCapacity(); + self.results.clearRetainingCapacity(); +} + +pub fn deinit(self: *Self) void { + self.flush(); + + self.calls.deinit(self.gpa); + self.values.deinit(self.gpa); + self.pool.deinit(self.gpa); + self.results.deinit(self.gpa); + + self.* = undefined; +} diff --git a/src/zilch/Env/value.zig b/src/zilch/Env/value.zig new file mode 100644 index 0000000..59b788f --- /dev/null +++ b/src/zilch/Env/value.zig @@ -0,0 +1,115 @@ +const std = @import("std"); +const Object = @import("../Object.zig"); + +pub fn isString(comptime T: type) bool { + return comptime blk: { + const info = @typeInfo(T); + if (info != .pointer) break :blk false; + + const ptr = &info.pointer; + if (ptr.is_volatile or ptr.is_allowzero) break :blk false; + + if (ptr.size == .slice) { + break :blk ptr.child == u8; + } + + if (ptr.size == .one) { + const child = @typeInfo(ptr.child); + if (child == .array) { + const arr = &child.array; + break :blk arr.child == u8; + } + } + + break :blk false; + }; +} + +pub const Value = extern struct { + kind: Kind, + value: extern union { + object: *Object, + string: extern struct { + ptr: [*]const u8, + len: usize, + }, + int: isize, + uint: usize, + float: f64, + undefined: void, + }, + + pub fn from(value: anytype) Value { + const T = @TypeOf(value); + + return switch (T) { + *Object => .{ + .kind = .object, + .value = .{ .object = value }, + }, + comptime_int => if (value >= 0) .{ + .kind = .uint, + .value = .{ .uint = value }, + } else .{ + .kind = .int, + .value = .{ .int = value }, + }, + usize => .{ + .kind = .uint, + .value = .{ .uint = value }, + }, + isize => .{ + .kind = .int, + .value = .{ .int = value }, + }, + f64, f32, f16 => .{ + .kind = .float, + .value = .{ .float = value }, + }, + void => .{ + .kind = .undefined, + .value = .{ .undefined = {} }, + }, + else => str: { + if (comptime isString(T)) { + break :str .{ + .kind = .string, + .value = .{ + .string = .{ + .ptr = @ptrCast(value), + .len = value.len, + }, + }, + }; + } else { + @compileError(std.fmt.comptimePrint( + "cannot auto convert type '{}'.", + .{T}, + )); + } + }, + }; + } + + pub const Kind = enum(u8) { + uninit = 0, + object = 1, + string = 2, + int = 3, + uint = 4, + float = 5, + undefined = 6, + + pub fn asType(comptime self: Kind) type { + return switch (self) { + .object => return *Object, + .string => return []const u8, + .int => return isize, + .uint => return usize, + .float => f64, + .undefined => return void, + .uninit => @compileError("uninit has no associated type."), + }; + } + }; +}; |