aboutsummaryrefslogtreecommitdiff
path: root/src/zilch/Env/root.zig
diff options
context:
space:
mode:
authorNathan Reiner <nathan@nathanreiner.xyz>2026-10-12 09:43:19 +0200
committerNathan Reiner <nathan@nathanreiner.xyz>2026-10-12 09:43:19 +0200
commit0b2af471b6d5dfc4eaf53639102c1b854bbb324b (patch)
treeaba3943b8c54d26d8552d0685d4178bc995d91c3 /src/zilch/Env/root.zig
parent812f547d84b5ce1a2924ae16f6257e4fd19efcc0 (diff)
first version of zilch
Diffstat (limited to 'src/zilch/Env/root.zig')
-rw-r--r--src/zilch/Env/root.zig162
1 files changed, 162 insertions, 0 deletions
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;
+}