debug/app.ona

@@ -1,8 +1,8 @@
 
-title = "Afterglow"
+@log_info("game is loading")
 
 return {
-    title = title,
+    title = "Afterglow",
     width = 1280,
     height = 800,
     tick_rate = 60,

source/coral/arena.zig

@@ -74,7 +74,7 @@ pub const Stacking = struct {
 		const aligned_size = (size + alignment - 1) & ~(alignment - 1);
 
 		if (self.pages.values.len == 0) {
-			const page = try self.allocate_page(math.max(self.min_page_size, aligned_size));
+			const page = try self.allocate_page(@max(self.min_page_size, aligned_size));
 
 			page.used = size;
 
@@ -84,7 +84,7 @@ pub const Stacking = struct {
 		var page = self.current_page() orelse unreachable;
 
 		if (page.available() <= aligned_size) {
-			page = try self.allocate_page(math.max(self.min_page_size, aligned_size));
+			page = try self.allocate_page(@max(self.min_page_size, aligned_size));
 		}
 
 		debug.assert(page.available() >= size);

source/coral/io.zig

@@ -96,7 +96,7 @@ pub const FixedBuffer = struct {
 	}
 
 	pub fn write(self: *FixedBuffer, bytes: []const Byte) usize {
-		const writable = math.min(self.bytes.len, bytes.len);
+		const writable = @min(self.bytes.len, bytes.len);
 
 		copy(self.bytes, bytes);
 
@@ -116,10 +116,7 @@ pub fn Functor(comptime Output: type, comptime Input: type) type {
 		pub fn bind(comptime State: type, state: *const State, comptime invoker: fn (capture: *const State, input: Input) Output) Self {
 			const is_zero_aligned = @alignOf(State) == 0;
 
-			return .{
-				.context = if (is_zero_aligned) state else @ptrCast(state),
-
-				.invoker = struct {
+			const Invoker = struct {
 				fn invoke(context: *const anyopaque, input: Input) Output {
 					if (is_zero_aligned) {
 						return invoker(@ptrCast(context), input);
@@ -127,7 +124,24 @@ pub fn Functor(comptime Output: type, comptime Input: type) type {
 
 					return invoker(@ptrCast(@alignCast(context)), input);
 				}
-				}.invoke,
+			};
+
+			return .{
+				.context = if (is_zero_aligned) state else @ptrCast(state),
+				.invoker = Invoker.invoke,
+			};
+		}
+
+		pub fn from(comptime invoker: fn (input: Input) Output) Self {
+			const Invoker = struct {
+				fn invoke(_: *const anyopaque, input: Input) Output {
+					return invoker(input);
+				}
+			};
+
+			return .{
+				.context = &.{},
+				.invoker = Invoker.invoke,
 			};
 		}
 
@@ -162,6 +176,19 @@ pub fn Generator(comptime Output: type, comptime Input: type) type {
 			};
 		}
 
+		pub fn from(comptime invoker: fn (input: Input) Output) Self {
+			const Invoker = struct {
+				fn invoke(_: *const anyopaque, input: Input) Output {
+					return invoker(input);
+				}
+			};
+
+			return .{
+				.context = &.{},
+				.invoker = Invoker.invoke,
+			};
+		}
+
 		pub fn invoke(self: Self, input: Input) Output {
 			return self.invoker(self.context, input);
 		}
@@ -223,6 +250,21 @@ pub fn copy(target: []Byte, source: []const Byte) void {
 	}
 }
 
+pub fn compare(this: []const Byte, that: []const Byte) isize {
+	const range = @min(this.len, that.len);
+	var index: usize = 0;
+
+	while (index < range) : (index += 1) {
+		const difference = @as(isize, @intCast(this[index])) - @as(isize, @intCast(that[index]));
+
+		if (difference != 0) {
+			return difference;
+		}
+	}
+
+	return @as(isize, @intCast(this.len)) - @as(isize, @intCast(that.len));
+}
+
 pub fn ends_with(target: []const Byte, match: []const Byte) bool {
 	if (target.len < match.len) {
 		return false;

source/coral/list.zig

@@ -49,6 +49,28 @@ pub fn Stack(comptime Value: type) type {
 			};
 		}
 
+		pub fn pack(self: *Self) io.AllocationError!void {
+			const packed_size = self.values.len;
+			const buffer = try self.allocator.reallocate(null, @sizeOf(Value) * self.values.len);
+
+			io.copy(buffer, io.bytes_of(self.values));
+
+			if (self.capacity != 0) {
+				self.allocator.deallocate(self.values.ptr[0 .. self.capacity]);
+			}
+
+			self.values = @as([*]Value, @ptrCast(@alignCast(buffer)))[0 .. packed_size];
+			self.capacity = packed_size;
+		}
+
+		pub fn peek(self: Self) ?Value {
+			if (self.values.len == 0) {
+				return null;
+			}
+
+			return self.values[self.values.len - 1];
+		}
+
 		pub fn pop(self: *Self) ?Value {
 			if (self.values.len == 0) {
 				return null;
@@ -61,9 +83,25 @@ pub fn Stack(comptime Value: type) type {
 			return self.values[last_index];
 		}
 
+		pub fn push_all(self: *Self, values: []const Value) io.AllocationError!void {
+			const new_length = self.values.len + values.len;
+
+			if (new_length > self.capacity) {
+				try self.grow(values.len + values.len);
+			}
+
+			const offset_index = self.values.len;
+
+			self.values = self.values.ptr[0 .. new_length];
+
+			for (0 .. values.len) |index| {
+				self.values[offset_index + index] = values[index];
+			}
+		}
+
 		pub fn push_one(self: *Self, value: Value) io.AllocationError!void {
 			if (self.values.len == self.capacity) {
-				try self.grow(math.max(1, self.capacity));
+				try self.grow(@max(1, self.capacity));
 			}
 
 			const offset_index = self.values.len;
@@ -74,3 +112,11 @@ pub fn Stack(comptime Value: type) type {
 		}
 	};
 }
+
+pub fn stack_as_writer(self: *ByteStack) io.Writer {
+	return io.Writer.bind(ByteStack, self, write_stack);
+}
+
+fn write_stack(stack: *ByteStack, bytes: []const io.Byte) ?usize {
+	return stack.push_all(bytes) catch null;
+}

source/coral/map.zig

@@ -55,6 +55,23 @@ pub fn Slab(comptime Value: type) type {
 			}
 		}
 
+		pub fn insert_at(self: *Self, key: usize, value: Value) bool {
+			if (self.entries.values.len < key) {
+				return false;
+			}
+
+			const entry = &self.entries.values[key - 1];
+
+			if (entry.* == .value) {
+				return false;
+			}
+
+			self.next_index = entry.next_index;
+			entry.* = .{.value = value};
+
+			return true;
+		}
+
 		pub fn make(allocator: io.Allocator) Self {
 			return .{
 				.next_index = 0,
@@ -86,8 +103,18 @@ pub fn Slab(comptime Value: type) type {
 	};
 }
 
+pub fn StringTable(comptime Value: type) type {
+	return Table([]const io.Byte, Value, .{
+		.hash = hash_string,
+		.match = io.equals,
+	});
+}
+
 pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTraits(Key)) type {
 	const load_max = 0.75;
+	const hash_int = @typeInfo(usize).Int;
+	const max_int = math.max_int(hash_int);
+	const min_int = math.min_int(hash_int);
 
 	return struct {
 		allocator: io.Allocator,
@@ -99,8 +126,8 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 			value: Value,
 
 			fn write_into(self: Entry, entry_table: []?Entry) bool {
-				const hash_max = math.min(math.max_int(@typeInfo(usize).Int), entry_table.len);
-				var hashed_key = math.wrap(traits.hash(self.key), math.min_int(@typeInfo(usize).Int), hash_max);
+				const hash_max = @min(max_int, entry_table.len);
+				var hashed_key = math.wrap(traits.hash(self.key), min_int, hash_max);
 				var iterations = @as(usize, 0);
 
 				while (true) : (iterations += 1) {
@@ -126,7 +153,7 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 
 		pub const Iterable = struct {
 			table: *Self,
-			iterations: usize = 0,
+			iterations: usize,
 
 			pub fn next(self: *Iterable) ?Entry {
 				while (self.iterations < self.table.entries.len) {
@@ -143,14 +170,40 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 
 		const Self = @This();
 
+		pub fn as_iterable(self: *Self) Iterable {
+			return .{
+				.table = self,
+				.iterations = 0,
+			};
+		}
+
+		pub fn remove(self: *Self, key: Key) ?Entry {
+			const hash_max = @min(max_int, self.entries.len);
+			var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
+
+			while (true) {
+				const entry = &(self.entries[hashed_key] orelse continue);
+
+				if (traits.match(entry.key, key)) {
+					const original_entry = entry.*;
+
+					self.entries[hashed_key] = null;
+
+					return original_entry;
+				}
+
+				hashed_key = (hashed_key +% 1) % hash_max;
+			}
+		}
+
 		pub fn replace(self: *Self, key: Key, value: Value) io.AllocationError!?Entry {
 			try self.rehash(load_max);
 
 			debug.assert(self.entries.len > self.count);
 
 			{
-				const hash_max = math.min(math.max_int(@typeInfo(usize).Int), self.entries.len);
-				var hashed_key = math.wrap(traits.hash(key), math.min_int(@typeInfo(usize).Int), hash_max);
+				const hash_max = @min(max_int, self.entries.len);
+				var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
 
 				while (true) {
 					const entry = &(self.entries[hashed_key] orelse {
@@ -223,8 +276,8 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 				return null;
 			}
 
-			const hash_max = math.min(math.max_int(@typeInfo(usize).Int), self.entries.len);
-			var hashed_key = math.wrap(traits.hash(key), math.min_int(@typeInfo(usize).Int), hash_max);
+			const hash_max = @min(max_int, self.entries.len);
+			var hashed_key = math.wrap(traits.hash(key), min_int, hash_max);
 			var iterations = @as(usize, 0);
 
 			while (iterations < self.count) : (iterations += 1) {
@@ -253,7 +306,7 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
 				return;
 			}
 
-			const min_count = math.max(1, self.count);
+			const min_count = @max(1, self.count);
 			const table_size = min_count * 2;
 			const allocation = @as([*]?Entry, @ptrCast(@alignCast(try self.allocator.reallocate(null, @sizeOf(?Entry) * table_size))))[0 .. table_size];
 
@@ -296,8 +349,3 @@ fn hash_string(key: []const io.Byte) usize {
 
 	return hash_code;
 }
-
-pub const string_table_traits = TableTraits([]const io.Byte){
-	.hash = hash_string,
-	.match = io.equals,
-};

source/coral/math.zig

@@ -1,7 +1,24 @@
 const std = @import("std");
 
-pub fn max(a: anytype, b: anytype) @TypeOf(a, b) {
-	return @max(a, b);
+pub fn Int(comptime int: std.builtin.Type.Int) type {
+	return @Type(.{.Int = int});
+}
+
+pub fn clamp(value: anytype, lower: anytype, upper: anytype) @TypeOf(value, lower, upper) {
+	return @max(lower, @min(upper, value));
+}
+
+pub fn clamped_cast(comptime dest_int: std.builtin.Type.Int, value: anytype) Int(dest_int) {
+	const Value = @TypeOf(value);
+
+	return switch (@typeInfo(Value)) {
+		.Int => |int| switch (int.signedness) {
+			.signed => @intCast(clamp(value, min_int(dest_int), max_int(dest_int))),
+			.unsigned => @intCast(@min(value, max_int(dest_int))),
+		},
+
+		else => @compileError("`" ++ @typeName(Value) ++ "` cannot be cast to an int"),
+	};
 }
 
 pub fn max_int(comptime int: std.builtin.Type.Int) comptime_int {
@@ -12,10 +29,6 @@ pub fn max_int(comptime int: std.builtin.Type.Int) comptime_int {
 	return (1 << (bit_count - @intFromBool(int.signedness == .signed))) - 1;
 }
 
-pub fn min(a: anytype, b: anytype) @TypeOf(a, b) {
-	return @min(a, b);
-}
-
 pub fn min_int(comptime int: std.builtin.Type.Int) comptime_int {
     if (int.signedness == .unsigned) return 0;
 

source/coral/utf8.zig

@@ -126,7 +126,7 @@ pub const DecimalFormat = struct {
 		switch (@typeInfo(ValueType)) {
 			.Int => |int| {
 				const radix = 10;
-				var buffer = [_]u8{0} ** (1 + math.max(int.bits, 1));
+				var buffer = [_]u8{0} ** (1 + @max(int.bits, 1));
 				var buffer_start = buffer.len - 1;
 
 				{

source/ona/app.zig

@@ -13,42 +13,57 @@ pub const Manifest = struct {
 	tick_rate: f32 = 60.0,
 
 	pub fn load(self: *Manifest, env: *kym.RuntimeEnv, file_access: file.Access) kym.RuntimeError!void {
-		const manifest = try env.execute_file(file_access, file.Path.from(&.{"app.ona"}));
+		const manifest_ref = try env.execute_file(file_access, file.Path.from(&.{"app.ona"}));
 
-		defer env.discard(manifest);
-
-		const title = try env.get_field(manifest, "title");
-
-		defer env.discard(title);
-
-		const title_string = try env.get_string(title);
+		defer env.discard(manifest_ref);
 
 		const width = @as(u16, get: {
-			const ref = try env.get_field(manifest, "width");
+			const ref = try kym.get_field(env, manifest_ref, "width");
 
 			defer env.discard(ref);
 
-			break: get @intFromFloat(env.get_float(ref) catch @as(f64, @floatFromInt(self.width)));
+			if (env.unbox(ref).expect_number()) |number| {
+				if (number > 0 and number < coral.math.max_int(@typeInfo(@TypeOf(self.width)).Int)) {
+					break: get @intFromFloat(number);
+				}
+			}
+
+			break: get self.width;
 		});
 
 		const height = @as(u16, get: {
-			const ref = try env.get_field(manifest, "height");
+			const ref = try kym.get_field(env, manifest_ref, "height");
 
 			defer env.discard(ref);
 
-			break: get @intFromFloat(env.get_float(ref) catch @as(f64, @floatFromInt(self.height)));
+			if (env.unbox(ref).expect_number()) |number| {
+				if (number > 0 and number < coral.math.max_int(@typeInfo(@TypeOf(self.height)).Int)) {
+					break: get @intFromFloat(number);
+				}
+			}
+
+			break: get self.height;
 		});
 
 		const tick_rate = @as(f32, get: {
-			const ref = try env.get_field(manifest, "tick_rate");
+			const ref = try kym.get_field(env, manifest_ref, "tick_rate");
 
 			defer env.discard(ref);
 
-			break: get @floatCast(env.get_float(ref) catch self.tick_rate);
+			if (env.unbox(ref).expect_number()) |number| {
+				break: get @floatCast(number);
+			}
+
+			break: get self.tick_rate;
 		});
 
 		{
-			const limited_title_len = coral.math.min(title_string.len, self.title.len);
+			const title_ref = try kym.get_field(env, manifest_ref, "title");
+
+			defer env.discard(title_ref);
+
+			const title_string = env.unbox(title_ref).expect_string() orelse "";
+			const limited_title_len = @min(title_string.len, self.title.len);
 
 			coral.io.copy(&self.title, title_string[0 .. limited_title_len]);
 			coral.io.zero(self.title[limited_title_len .. self.title.len]);
@@ -60,69 +75,29 @@ pub const Manifest = struct {
 	}
 };
 
-pub const LogSeverity = enum {
-	info,
-	warn,
-	fail,
-};
+pub fn log_info(message: []const coral.io.Byte) void {
+	ext.SDL_LogInfo(
+		ext.SDL_LOG_CATEGORY_APPLICATION,
+		"%.*s",
+		coral.math.clamped_cast(@typeInfo(c_int).Int, message.len),
+		message.ptr,
+	);
+}
 
-pub const WritableLog = struct {
-	severity: LogSeverity,
-	write_buffer: coral.list.ByteStack,
+pub fn log_warn(message: []const coral.io.Byte) void {
+	ext.SDL_LogWarn(
+		ext.SDL_LOG_CATEGORY_APPLICATION,
+		"%.*s",
+		coral.math.clamped_cast(@typeInfo(c_int).Int, message.len),
+		message.ptr,
+	);
+}
 
-	pub fn as_writer(self: *WritableLog) coral.io.Writer {
-		return coral.io.Writer.bind(WritableLog, self, struct {
-			fn write(writable_log: *WritableLog, bytes: []const coral.io.Byte) ?usize {
-				writable_log.write(bytes) catch return null;
-
-				return bytes.len;
-			}
-		}.write);
-	}
-
-	pub fn free(self: *WritableLog) void {
-		self.write_buffer.free();
-	}
-
-	pub fn make(log_severity: LogSeverity, allocator: coral.io.Allocator) WritableLog {
-		return .{
-			.severity = log_severity,
-			.write_buffer = coral.list.ByteStack.make(allocator),
-		};
-	}
-
-	pub fn write(self: *WritableLog, bytes: []const coral.io.Byte) coral.io.AllocationError!void {
-		const format_string = "%.*s";
-		var line_written = @as(usize, 0);
-
-		for (bytes) |byte| {
-			if (byte == '\n') {
+pub fn log_fail(message: []const coral.io.Byte) void {
 	ext.SDL_LogError(
 		ext.SDL_LOG_CATEGORY_APPLICATION,
-					format_string,
-					self.write_buffer.values.len,
-					self.write_buffer.values.ptr);
-
-				self.write_buffer.clear();
-
-				line_written = 0;
-
-				continue;
-			}
-
-			try self.write_buffer.push_one(byte);
-
-			line_written += 1;
-		}
-
-		if (self.write_buffer.values.len == 0) {
-			ext.SDL_LogError(
-				ext.SDL_LOG_CATEGORY_APPLICATION,
-				format_string,
-				self.write_buffer.values.len,
-				self.write_buffer.values.ptr);
-
-			self.write_buffer.clear();
-		}
-	}
-};
+		"%.*s",
+		coral.math.clamped_cast(@typeInfo(c_int).Int, message.len),
+		message.ptr,
+	);
+}

source/ona/heap.zig

@@ -156,15 +156,15 @@ pub const allocator = coral.io.Allocator.bind(Context, &context, .{
 pub fn trace_leaks() void {
 	switch (builtin.mode) {
 		.Debug, .ReleaseSafe => {
-			var current_allocation_info = context.allocation_info_head;
+			var current_node = context.head;
 
-			while (current_allocation_info) |allocation_info| : (current_allocation_info = allocation_info.next_info) {
+			while (current_node) |node| : (current_node = node.next) {
 				std.debug.print("{d} byte leak at 0x{x} detected:\n", .{
-					allocation_info.size,
-					@as(usize, allocation_info) + @sizeOf(AllocationNode),
+					node.size,
+					@intFromPtr(node) + @sizeOf(AllocationNode),
 				});
 
-				allocation_info.trace.dump();
+				node.trace.dump();
 			}
 		},
 

source/ona/kym/Ast.zig

@@ -5,17 +5,22 @@ const tokens = @import("./tokens.zig");
 allocator: coral.io.Allocator,
 arena: coral.arena.Stacking,
 statements: Statement.List,
-error_message: []const u8,
+error_message: []const coral.io.Byte,
 
 pub const Expression = union (enum) {
 	nil_literal,
 	true_literal,
 	false_literal,
-	number_literal: []const u8,
-	string_literal: []const u8,
+	number_literal: []const coral.io.Byte,
+	string_literal: []const coral.io.Byte,
 	table_literal: NamedList,
 	grouped_expression: *Expression,
-	get_local: []const u8,
+	get_local: []const coral.io.Byte,
+
+	call_system: struct {
+		identifier: []const coral.io.Byte,
+		argument_expressions: List,
+	},
 
 	binary_operation: struct {
 		operator: BinaryOperator,
@@ -55,7 +60,7 @@ pub const Expression = union (enum) {
 	};
 
 	pub const NamedList = coral.list.Stack(struct {
-		identifier: []const u8,
+		identifier: []const coral.io.Byte,
 		expression: Expression,
 	});
 
@@ -80,6 +85,11 @@ pub const Statement = union (enum) {
 		expression: Expression,
 	},
 
+	call_system: struct {
+		identifier: []const coral.io.Byte,
+		argument_expressions: Expression.List,
+	},
+
 	const List = coral.list.Stack(Statement);
 };
 
@@ -88,13 +98,14 @@ const UnaryOperator = enum {
 	numeric_negation,
 };
 
-fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime operators: []const Expression.BinaryOperator) ExpressionParser {
-	return struct {
-		fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression {
-			var expression = try parse_next(self, tokenizer);
+fn binary_operation_parser(
+	comptime parse_next: ExpressionParser,
+	comptime operators: []const Expression.BinaryOperator) ExpressionParser {
 
-			{
+	const BinaryOperationParser = struct {
+		fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression {
 			const allocator = self.arena.as_allocator();
+			var expression = try parse_next(self, tokenizer);
 
 			inline for (operators) |operator| {
 				const token = comptime operator.token();
@@ -103,8 +114,7 @@ fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime opera
 					tokenizer.step();
 
 					if (tokenizer.token == null) {
-							return self.raise(
-								"expected right-hand side of expression after `" ++ comptime token.text() ++ "`");
+						return self.raise("expected other half of expression after `" ++ comptime token.text() ++ "`");
 					}
 
 					expression = .{
@@ -116,11 +126,12 @@ fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime opera
 					};
 				}
 			}
-			}
 
 			return expression;
 		}
-	}.parse;
+	};
+
+	return BinaryOperationParser.parse;
 }
 
 pub fn free(self: *Self) void {
@@ -150,9 +161,12 @@ pub fn list_statements(self: Self) []const Statement {
 pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!void {
 	self.free();
 
+	const allocator = self.arena.as_allocator();
 	var has_returned = false;
 
 	while (true) {
+		const no_effect_message = "statement has no effect";
+
 		tokenizer.skip(.newline);
 
 		switch (tokenizer.token orelse return) {
@@ -178,11 +192,9 @@ pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!void {
 				has_returned = true;
 			},
 
-			.local => |identifier| {
+			.identifier => |identifier| {
 				tokenizer.step();
 
-				const no_effect_message = "statement has no effect";
-
 				switch (tokenizer.token orelse return self.raise(no_effect_message)) {
 					.newline => return self.raise(no_effect_message),
 
@@ -209,6 +221,45 @@ pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!void {
 				}
 			},
 
+			.special_identifier => |identifier| {
+				tokenizer.step();
+
+				switch (tokenizer.token orelse return self.raise(no_effect_message)) {
+					.newline => return self.raise(no_effect_message),
+
+					.symbol_paren_left => {
+						tokenizer.step();
+
+						var expressions_list = Expression.List.make(allocator);
+
+						while (true) {
+							if (tokenizer.is_token(.symbol_paren_right)) {
+								break;
+							}
+
+							try expressions_list.push_one(try self.parse_expression(tokenizer));
+
+							switch (tokenizer.token orelse return self.raise("unexpected end after after `(`")) {
+								.symbol_comma => continue,
+								.symbol_paren_right => break,
+								else => return self.raise("expected `)` or argument after `(`"),
+							}
+						}
+
+						tokenizer.step();
+
+						try self.statements.push_one(.{
+							.call_system = .{
+								.argument_expressions = expressions_list,
+								.identifier = identifier,
+							},
+						});
+					},
+
+					else => return self.raise("expected `=` after local"),
+				}
+			},
+
 			else => return self.raise("invalid statement"),
 		}
 	}
@@ -252,6 +303,24 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression
 			return Expression{.grouped_expression = try coral.io.allocate_one(allocator, expression)};
 		},
 
+		.keyword_nil => {
+			tokenizer.step();
+
+			return .nil_literal;
+		},
+
+		.keyword_true => {
+			tokenizer.step();
+
+			return .true_literal;
+		},
+
+		.keyword_false => {
+			tokenizer.step();
+
+			return .false_literal;
+		},
+
 		.number => |value| {
 			tokenizer.step();
 
@@ -264,7 +333,49 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression
 			return Expression{.string_literal = value};
 		},
 
-		.local => |identifier| {
+		.special_identifier => |identifier| {
+			tokenizer.skip(.newline);
+
+			var expression_list = Expression.List.make(allocator);
+
+			while (true) {
+				switch (tokenizer.token orelse return self.raise("expected expression or `)` after `(`")) {
+					.symbol_paren_right => {
+						tokenizer.step();
+
+						return Expression{
+							.call_system = .{
+								.identifier = identifier,
+								.argument_expressions = expression_list,
+							},
+						};
+					},
+
+					else => {
+						try expression_list.push_one(try self.parse_expression(tokenizer));
+
+						switch (tokenizer.token orelse return self.raise("expected `,` or `)` after argument")) {
+							.symbol_comma => continue,
+
+							.symbol_paren_right => {
+								tokenizer.step();
+
+								return Expression{
+									.call_system = .{
+										.identifier = identifier,
+										.argument_expressions = expression_list,
+									},
+								};
+							},
+
+							else => return self.raise("expected `,` or `)` after argument"),
+						}
+					},
+				}
+			}
+		},
+
+		.identifier => |identifier| {
 			tokenizer.step();
 
 			return Expression{.get_local = identifier};
@@ -283,7 +394,7 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression
 						return Expression{.table_literal = table_fields};
 					},
 
-					.local => |identifier| {
+					.identifier => |identifier| {
 						tokenizer.skip(.newline);
 
 						if (!tokenizer.is_token(.symbol_equals)) {

source/ona/kym/Chunk.zig

@@ -0,0 +1,512 @@
+const Ast = @import("./Ast.zig");
+
+const coral = @import("coral");
+
+const kym = @import("../kym.zig");
+
+env: *kym.RuntimeEnv,
+constant_refs: RefList,
+opcodes: OpcodeList,
+
+const AstCompiler = struct {
+	chunk: *Self,
+	local_identifiers_buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
+	local_identifiers_count: u8 = 0,
+
+	fn compile_expression(self: *AstCompiler, expression: Ast.Expression) kym.RuntimeError!void {
+		const number_format = coral.utf8.DecimalFormat{
+			.delimiter = "_",
+			.positive_prefix = .none,
+		};
+
+		switch (expression) {
+			.nil_literal => try self.chunk.append_opcode(.push_nil),
+			.true_literal => try self.chunk.append_opcode(.push_true),
+			.false_literal => try self.chunk.append_opcode(.push_false),
+
+			.number_literal => |literal| {
+				const parsed_number = number_format.parse(literal, kym.Float);
+
+				coral.debug.assert(parsed_number != null);
+
+				try self.chunk.append_opcode(.{
+					.push_const = try self.chunk.declare_constant_number(parsed_number.?),
+				});
+			},
+
+			.string_literal => |literal| {
+				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(literal)});
+			},
+
+			.table_literal => |fields| {
+				if (fields.values.len > coral.math.max_int(@typeInfo(u32).Int)) {
+					return error.OutOfMemory;
+				}
+
+				for (fields.values) |field| {
+					try self.compile_expression(field.expression);
+
+					try self.chunk.append_opcode(.{
+						.push_const = try self.chunk.declare_constant_string(field.identifier),
+					});
+				}
+
+				try self.chunk.append_opcode(.{.push_table = @intCast(fields.values.len)});
+			},
+
+			.binary_operation => |operation| {
+				try self.compile_expression(operation.lhs_expression.*);
+				try self.compile_expression(operation.rhs_expression.*);
+
+				try self.chunk.append_opcode(switch (operation.operator) {
+					.addition => .add,
+					.subtraction => .sub,
+					.multiplication => .mul,
+					.divsion => .div,
+					.greater_equals_comparison => .eql,
+					.greater_than_comparison => .cgt,
+					.equals_comparison => .cge,
+					.less_than_comparison => .clt,
+					.less_equals_comparison => .cle,
+				});
+			},
+
+			.unary_operation => |operation| {
+				try self.compile_expression(operation.expression.*);
+
+				try self.chunk.append_opcode(switch (operation.operator) {
+					.boolean_negation => .not,
+					.numeric_negation => .neg,
+				});
+			},
+
+			.grouped_expression => |grouped_expression| {
+				try self.compile_expression(grouped_expression.*);
+			},
+
+			.get_local => |local| {
+				try self.chunk.append_opcode(.{
+					.push_local = self.resolve_local(local) orelse return self.chunk.env.raise(error.OutOfMemory, "undefined local"),
+				});
+			},
+
+			.call_system => |call| {
+				if (call.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
+					return self.chunk.env.raise(error.OutOfMemory, "functions may receive a maximum of 255 locals");
+				}
+
+				for (call.argument_expressions.values) |argument_expression| {
+					try self.compile_expression(argument_expression);
+				}
+
+				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(call.identifier)});
+				try self.chunk.append_opcode(.{.syscall = @intCast(call.argument_expressions.values.len)});
+				try self.chunk.append_opcode(.pop);
+			},
+		}
+	}
+
+	fn compile_statement(self: *AstCompiler, statement: Ast.Statement) kym.RuntimeError!void {
+		switch (statement) {
+			.return_expression => |return_expression| try self.compile_expression(return_expression),
+			.return_nothing => try self.chunk.append_opcode(.push_nil),
+
+			.set_local => |local| {
+				try self.compile_expression(local.expression);
+
+				if (self.resolve_local(local.identifier)) |index| {
+					try self.chunk.append_opcode(.{.set_local = index});
+				} else {
+					try self.declare_local(local.identifier);
+				}
+			},
+
+			.call_system => |call| {
+				if (call.argument_expressions.values.len > coral.math.max_int(@typeInfo(u8).Int)) {
+					return self.chunk.env.raise(error.OutOfMemory, "functions may receive a maximum of 255 locals");
+				}
+
+				for (call.argument_expressions.values) |argument_expression| {
+					try self.compile_expression(argument_expression);
+				}
+
+				try self.chunk.append_opcode(.{.push_const = try self.chunk.declare_constant_string(call.identifier)});
+				try self.chunk.append_opcode(.{.syscall = @intCast(call.argument_expressions.values.len)});
+				try self.chunk.append_opcode(.pop);
+			}
+		}
+	}
+
+	fn declare_local(self: *AstCompiler, identifier: []const u8) kym.RuntimeError!void {
+		if (self.local_identifiers_count == self.local_identifiers_buffer.len) {
+			return self.chunk.env.raise(error.OutOfMemory, "functions may contain a maximum of 255 locals");
+		}
+
+		self.local_identifiers_buffer[self.local_identifiers_count] = identifier;
+		self.local_identifiers_count += 1;
+	}
+
+	fn resolve_local(self: *AstCompiler, local_identifier: []const coral.io.Byte) ?u8 {
+		if (self.local_identifiers_count == 0) {
+			return null;
+		}
+
+		var index = @as(u8, self.local_identifiers_count - 1);
+
+		while (true) : (index -= 1) {
+			if (coral.io.equals(local_identifier, self.local_identifiers_buffer[index])) {
+				return index;
+			}
+
+			if (index == 0) {
+				return null;
+			}
+		}
+	}
+};
+
+pub const Constant = u16;
+
+const RefList = coral.list.Stack(?*kym.RuntimeRef);
+
+const LocalsList = coral.list.Stack([]const u8);
+
+pub const Opcode = union (enum) {
+	pop,
+	push_nil,
+	push_true,
+	push_false,
+	push_const: Constant,
+	push_local: u8,
+	push_table: u32,
+	set_local: u8,
+	call: u8,
+	syscall: u8,
+
+	not,
+	neg,
+
+	add,
+	sub,
+	mul,
+	div,
+
+	eql,
+	cgt,
+	clt,
+	cge,
+	cle,
+};
+
+const OpcodeList = coral.list.Stack(Opcode);
+
+const Self = @This();
+
+pub fn append_opcode(self: *Self, opcode: Opcode) kym.RuntimeError!void {
+	return self.opcodes.push_one(opcode);
+}
+
+pub fn as_caller(self: *Self) kym.Caller {
+	return kym.Caller.bind(Self, self, execute);
+}
+
+pub fn compile_ast(self: *Self, ast: Ast) kym.RuntimeError!void {
+	try self.constant_refs.grow(coral.math.max_int(@typeInfo(u16).Int));
+
+	var compiler = AstCompiler{.chunk = self};
+
+	for (ast.list_statements()) |statement| {
+		try compiler.compile_statement(statement);
+	}
+
+	try self.constant_refs.pack();
+	try self.opcodes.pack();
+}
+
+pub fn declare_constant_number(self: *Self, constant: kym.Float) kym.RuntimeError!Constant {
+	const tail = self.constant_refs.values.len;
+
+	if (tail == coral.math.max_int(@typeInfo(u16).Int)) {
+		return self.env.raise(error.BadSyntax, "functions may contain a maximum of 65,535 constants");
+	}
+
+	const constant_ref = try self.env.new_number(constant);
+
+	errdefer self.env.discard(constant_ref);
+
+	try self.constant_refs.push_one(constant_ref);
+
+	return @intCast(tail);
+}
+
+pub fn declare_constant_string(self: *Self, constant: []const coral.io.Byte) kym.RuntimeError!Constant {
+	const tail = self.constant_refs.values.len;
+
+	if (tail == coral.math.max_int(@typeInfo(u16).Int)) {
+		return self.env.raise(error.BadSyntax, "functions may contain a maximum of 65,535 constants");
+	}
+
+	const constant_ref = try self.env.new_string(constant);
+
+	errdefer self.env.discard(constant_ref);
+
+	try self.constant_refs.push_one(constant_ref);
+
+	return @intCast(tail);
+}
+
+fn execute(self: *Self, env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
+	for (self.opcodes.values) |opcode| {
+		switch (opcode) {
+			.pop => env.discard(try env.pop_local()),
+			.push_nil => try env.push_ref(null),
+			.push_true => try env.push_boolean(true),
+			.push_false => try env.push_boolean(false),
+			.push_const => |constant| try env.push_ref(self.constant_refs.values[constant]),
+
+			.push_table => |field_count| {
+				const table_ref = try kym.new_table(env);
+
+				defer env.discard(table_ref);
+
+				{
+					const dynamic = try kym.unbox_dynamic(env, table_ref);
+					var popped = @as(usize, 0);
+
+					while (popped < field_count) : (popped += 1) {
+						const index_ref = try env.pop_local();
+
+						defer env.discard(index_ref);
+
+						const value_ref = try env.pop_local();
+
+						defer env.discard(value_ref);
+
+						try dynamic.typeinfo.set(.{
+							.userdata = dynamic.userdata,
+							.env = env,
+							.index_ref = index_ref,
+						}, value_ref);
+					}
+				}
+
+				try env.push_ref(table_ref);
+			},
+
+			.push_local => |local| {
+				const ref = try env.get_local(local);
+
+				defer env.discard(ref);
+
+				try env.push_ref(ref);
+			},
+
+			.set_local => |local| {
+				const ref = try env.pop_local();
+
+				defer env.discard(ref);
+
+				try env.set_local(local, ref);
+			},
+
+			.call => |arg_count| {
+				const result_ref = call: {
+					const callable_ref = try env.pop_local();
+
+					defer env.discard(callable_ref);
+
+					break: call try env.call("", arg_count, (try kym.unbox_dynamic(env, callable_ref)).as_caller());
+				};
+
+				defer env.discard(result_ref);
+
+				try env.push_ref(result_ref);
+			},
+
+			.syscall => |arg_count| {
+				const result_ref = call: {
+					const identifier_ref = try env.pop_local();
+
+					defer env.discard(identifier_ref);
+
+					const identifier = try kym.unbox_string(env, identifier_ref);
+
+					break: call try env.call(identifier, arg_count, try env.syscaller(identifier));
+				};
+
+				defer env.discard(result_ref);
+
+				try env.push_ref(result_ref);
+			},
+
+			.neg => try env.push_number(switch (env.unbox(try env.pop_local())) {
+				.number => |number| -number,
+				else => return env.raise(error.TypeMismatch, "object is not scalar negatable"),
+			}),
+
+			.not => try env.push_boolean(switch (env.unbox(try env.pop_local())) {
+				.boolean => |boolean| !boolean,
+				else => return env.raise(error.TypeMismatch, "object is not boolean negatable"),
+			}),
+
+			.add => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_ref(try switch (env.unbox(lhs_ref)) {
+					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
+						.number => |rhs_number| env.new_number(lhs_number + rhs_number),
+						else => return env.raise(error.TypeMismatch, "right-hand object is not addable"),
+					},
+
+					else => return env.raise(error.TypeMismatch, "left-hand object is not addable"),
+				});
+			},
+
+			.sub => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_ref(try switch (env.unbox(lhs_ref)) {
+					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
+						.number => |rhs_number| env.new_number(lhs_number - rhs_number),
+						else => return env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
+					},
+
+					else => return env.raise(error.TypeMismatch, "left-hand object is not subtractable"),
+				});
+			},
+
+			.mul => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_ref(try switch (env.unbox(lhs_ref)) {
+					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
+						.number => |rhs_number| env.new_number(lhs_number * rhs_number),
+						else => return env.raise(error.TypeMismatch, "right-hand object is not multiplyable"),
+					},
+
+					else => return env.raise(error.TypeMismatch, "left-hand object is not multiplyable"),
+				});
+			},
+
+			.div => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_ref(try switch (env.unbox(lhs_ref)) {
+					.number => |lhs_number| switch (env.unbox(rhs_ref)) {
+						.number => |rhs_number| env.new_number(lhs_number / rhs_number),
+						else => return env.raise(error.TypeMismatch, "right-hand object is not divisable"),
+					},
+
+					else => return env.raise(error.TypeMismatch, "left-hand object is not divisable"),
+				});
+			},
+
+			.eql => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_boolean(try kym.test_equality(env, lhs_ref, rhs_ref));
+			},
+
+			.cgt => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) > 0);
+			},
+
+			.clt => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) < 0);
+			},
+
+			.cge => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) >= 0);
+			},
+
+			.cle => {
+				const rhs_ref = try env.pop_local();
+
+				defer env.discard(rhs_ref);
+
+				const lhs_ref = try env.pop_local();
+
+				defer env.discard(lhs_ref);
+
+				try env.push_boolean(try kym.test_difference(env, lhs_ref, rhs_ref) <= 0);
+			},
+		}
+	}
+
+	return env.pop_local();
+}
+
+pub fn free(self: *Self) void {
+	for (self.constant_refs.values) |constant| {
+		self.env.discard(constant);
+	}
+
+	self.opcodes.free();
+	self.constant_refs.free();
+}
+
+fn is_zero(utf8: []const u8) bool {
+	return coral.io.equals(utf8, "0") or coral.io.equals(utf8, "0.0");
+}
+
+pub fn make(env: *kym.RuntimeEnv) Self {
+	return Self{
+		.opcodes = OpcodeList.make(env.allocator),
+		.constant_refs = RefList.make(env.allocator),
+		.env = env,
+	};
+}

source/ona/kym/State.zig

@@ -1,148 +0,0 @@
-const coral = @import("coral");
-
-allocator: coral.io.Allocator,
-interned: SymbolTable,
-globals: Object,
-values: DataStack,
-frames: CallStack,
-
-pub const Float = f64;
-
-const CallStack = coral.list.Stack(struct {
-	callable: *Object,
-	opcode_index: usize,
-	stack_index: usize,
-});
-
-const DataStack = coral.list.Stack(Variant);
-
-pub const Object = struct {
-	ref_count: usize,
-	userdata: []coral.io.Byte,
-	userinfo: *const anyopaque,
-};
-
-pub const PopError = error {
-	StackOverflow,
-};
-
-const Self = @This();
-
-const SymbolTable = coral.map.Table([]const coral.io.Byte, *Object, coral.map.string_table_traits);
-
-pub const Variant = union (enum) {
-	nil,
-	true,
-	false,
-	number: Float,
-	object: *Object,
-
-	pub fn equals(self: Variant, other: Variant) bool {
-		return switch (self) {
-			.nil => other == .nil,
-			.true => other == .true,
-			.false => other == .false,
-
-			.number => |number| switch (other) {
-				.number => |other_number| number == other_number,
-				else => false,
-			},
-
-			.object => |object| switch (other) {
-				.object => |other_object| object == other_object,
-				else => false,
-			},
-		};
-	}
-};
-
-pub fn acquire_instance(_: *Self, object: *Object) *Object {
-	// TODO: safety-check object belongs to state.
-	object.ref_count += 1;
-
-	return object;
-}
-
-pub fn acquire_interned(self: *Self, userdata: []const u8, userinfo: *const anyopaque) coral.io.AllocationError!*Object {
-	// TODO: Include userinfo in matching lookup.
-	if (self.interned.lookup(userdata)) |object| {
-		return self.acquire_instance(object);
-	} else {
-		const data_object = try self.acquire_new(userdata, userinfo);
-
-		errdefer self.release(data_object);
-
-		coral.debug.assert(try self.interned.insert(data_object.userdata, data_object));
-
-		return data_object;
-	}
-}
-
-pub fn acquire_new(self: *Self, userdata: []const u8, userinfo: *const anyopaque) coral.io.AllocationError!*Object {
-	const allocated_userdata = try coral.io.allocate_copy(self.allocator, userdata);
-
-	errdefer self.allocator.deallocate(allocated_userdata);
-
-	const allocated_object = try coral.io.allocate_one(self.allocator, Object{
-		.ref_count = 1,
-		.userdata = allocated_userdata,
-		.userinfo = userinfo,
-	});
-
-	errdefer self.allocator.deallocate(allocated_object);
-
-	return allocated_object;
-}
-
-pub fn free(self: *Self) void {
-	self.values.free();
-	self.frames.free();
-	self.interned.free();
-}
-
-pub fn get_value(self: *Self, index: u8) Variant {
-	return if (index < self.values.values.len) self.values.values[index] else .nil;
-}
-
-pub fn make(allocator: coral.io.Allocator) Self {
-	return .{
-		.values = DataStack.make(allocator),
-		.frames = CallStack.make(allocator),
-		.interned = SymbolTable.make(allocator),
-		.allocator = allocator,
-
-		.globals = .{
-			.ref_count = 0,
-			.userdata = &.{},
-			.userinfo = &.{},
-		},
-	};
-}
-
-pub fn pop_value(self: *Self) PopError!Variant {
-	return self.values.pop() orelse error.StackOverflow;
-}
-
-pub fn push_value(self: *Self, value: Variant) coral.io.AllocationError!void {
-	return self.values.push_one(value);
-}
-
-pub fn release(self: *Self, object: *Object) void {
-	coral.debug.assert(object.ref_count != 0);
-
-	object.ref_count -= 1;
-
-	if (object.ref_count == 0) {
-		self.allocator.deallocate(object);
-	}
-}
-
-pub fn set_value(self: *Self, index: u8, value: Variant) bool {
-	if (index >= self.values.values.len) {
-		return false;
-	}
-
-	self.values.values[index] = value;
-
-	return true;
-}

source/ona/kym/Table.zig

@@ -1,76 +1,91 @@
-const State = @import("./State.zig");
-
 const coral = @import("coral");
 
-state: *State,
+const kym = @import("../kym.zig");
+
 fields: FieldTable,
-array: ArrayList,
 
-const ArrayList = coral.list.Stack(State.Variant);
-
-const Field = struct {
-	field: *State.Object,
-	value: State.Variant,
-
-	fn release_objects(self: Field, state: *State) void {
-		state.release(self.field);
-
-		if (self.value == .object) {
-			state.release(self.value.object);
-		}
-	}
-};
-
-const FieldTable = coral.map.Table([]const coral.io.Byte, Field, coral.map.string_table_traits);
+const FieldTable = coral.map.StringTable(struct {
+	key_ref: ?*kym.RuntimeRef,
+	value_ref: ?*kym.RuntimeRef,
+});
 
 const Self = @This();
 
-pub fn free(self: *Self) void {
-	{
-		var field_iterator = FieldTable.Iterable{.table = &self.fields};
-
-		while (field_iterator.next()) |entry| {
-			entry.value.release_objects(self.state);
-		}
-	}
+pub fn new(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
+	var self = Self{
+		.fields = FieldTable.make(env.allocator),
+	};
 
+	errdefer {
 		self.fields.free();
-	self.array.free();
-}
-
-pub fn get_field(self: *Self, field_name: *State.Object) State.Variant {
-	const field = self.fields.lookup(field_name.userdata) orelse return .nil;
-
-	if (field.value == .object) {
-		return .{.object = self.state.acquire_instance(field.value.object)};
 	}
 
-	return field.value;
+	return try env.new_dynamic(coral.io.bytes_of(&self), &typeinfo);
 }
 
-pub fn get_index(self: *Self, index: usize) State.Variant {
-	return self.array.values[index];
+const typeinfo = kym.Typeinfo{
+	.name = "table",
+	.clean = typeinfo_clean,
+	.get = typeinfo_get,
+	.set = typeinfo_set,
+};
+
+fn typeinfo_clean(env: *kym.RuntimeEnv, userdata: []coral.io.Byte) void {
+	const table = @as(*Self, @ptrCast(@alignCast(userdata.ptr)));
+
+	{
+		var field_iterable = table.fields.as_iterable();
+
+		while (field_iterable.next()) |entry| {
+			env.discard(entry.value.key_ref);
+			env.discard(entry.value.value_ref);
+		}
+	}
+
+	table.fields.free();
 }
 
-pub fn make(allocator: coral.io.Allocator, state: *State) Self {
-	return .{
-		.state = state,
-		.fields = FieldTable.make(allocator),
-		.array = ArrayList.make(allocator),
+fn typeinfo_get(context: kym.IndexContext) kym.RuntimeError!?*kym.RuntimeRef {
+	const table = @as(*Self, @ptrCast(@alignCast(context.userdata.ptr)));
+
+	return switch (context.env.unbox(context.index_ref)) {
+		.string => |string| context.env.acquire((table.fields.lookup(string) orelse return null).value_ref),
+		// TODO: Implement number indices in tables.
+		.number => |_| unreachable,
+		else => context.env.raise(error.TypeMismatch, "table objects may only be indexed with strings or numbers"),
 	};
 }
 
-pub fn set_field(self: *Self, field_name: *State.Object, value: State.Variant) coral.io.AllocationError!void {
-	const previous_entry = try self.fields.replace(field_name.userdata, .{
-		.field = field_name,
-		.value = value,
-	});
+fn typeinfo_set(context: kym.IndexContext, value_ref: ?*const kym.RuntimeRef) kym.RuntimeError!void {
+	const table = @as(*Self, @ptrCast(@alignCast(context.userdata.ptr)));
+	const acquired_value_ref = context.env.acquire(value_ref);
 
-	if (previous_entry) |entry| {
-		entry.value.release_objects(self.state);
+	errdefer context.env.discard(acquired_value_ref);
+
+	switch (context.env.unbox(context.index_ref)) {
+		.string => |string| {
+			const acquired_index_ref = context.env.acquire(context.index_ref);
+
+			errdefer context.env.discard(acquired_index_ref);
+
+			var displaced_table_entry = if (acquired_value_ref) |ref| try table.fields.replace(string, .{
+				.key_ref = acquired_index_ref,
+				.value_ref = ref,
+			}) else table.fields.remove(string);
+
+			if (displaced_table_entry) |*entry| {
+				context.env.discard(entry.value.key_ref);
+				context.env.discard(entry.value.value_ref);
+			}
+		},
+
+		.number => |_| {
+			// TODO: Implement number indices in tables.
+			unreachable;
+		},
+
+		else => {
+			return context.env.raise(error.TypeMismatch, "table objects may only be indexed with strings or numbers");
+		},
 	}
 }
-
-pub fn set_index(self: *Self, index: usize, value: State.Variant) coral.io.AllocationError!void {
-	self.array.values[index] = value;
-}

source/ona/kym/tokens.zig

@@ -1,11 +1,11 @@
 const coral = @import("coral");
 
 pub const Token = union(enum) {
-	unknown: u8,
+	unknown: coral.io.Byte,
 	newline,
 
-	global: []const u8,
-	local: []const u8,
+	special_identifier: []const coral.io.Byte,
+	identifier: []const coral.io.Byte,
 
 	symbol_plus,
 	symbol_minus,
@@ -29,8 +29,8 @@ pub const Token = union(enum) {
 	symbol_equals,
 	symbol_double_equals,
 
-	number: []const u8,
-	string: []const u8,
+	number: []const coral.io.Byte,
+	string: []const coral.io.Byte,
 
 	keyword_nil,
 	keyword_false,
@@ -39,13 +39,13 @@ pub const Token = union(enum) {
 	keyword_self,
 	keyword_const,
 
-	pub fn text(self: Token) []const u8 {
+	pub fn text(self: Token) []const coral.io.Byte {
 		return switch (self) {
-			.unknown => |unknown| @as([*]const u8, @ptrCast(&unknown))[0 .. 1],
+			.unknown => |unknown| @as([*]const coral.io.Byte, @ptrCast(&unknown))[0 .. 1],
 			.newline => "newline",
 
-			.global => |identifier| identifier,
-			.local => |identifier| identifier,
+			.special_identifier => |identifier| identifier,
+			.identifier => |identifier| identifier,
 
 			.symbol_plus => "+",
 			.symbol_minus => "-",
@@ -83,7 +83,7 @@ pub const Token = union(enum) {
 };
 
 pub const Tokenizer = struct {
-	source: []const u8,
+	source: []const coral.io.Byte,
 	lines_stepped: usize = 1,
 	token: ?Token = null,
 
@@ -217,7 +217,7 @@ pub const Tokenizer = struct {
 						else => {},
 					}
 
-					self.token = .{.local = identifier};
+					self.token = .{.identifier = identifier};
 
 					return;
 				},
@@ -236,7 +236,7 @@ pub const Tokenizer = struct {
 								else => break,
 							};
 
-							self.token = .{.global = self.source[begin .. cursor]};
+							self.token = .{.special_identifier = self.source[begin .. cursor]};
 
 							return;
 						},
@@ -253,7 +253,7 @@ pub const Tokenizer = struct {
 								else => cursor += 1,
 							};
 
-							self.token = .{.global = self.source[begin .. cursor]};
+							self.token = .{.special_identifier = self.source[begin .. cursor]};
 							cursor += 1;
 
 							return;

source/ona/ona.zig

@@ -10,73 +10,87 @@ const heap = @import("./heap.zig");
 
 const kym = @import("./kym.zig");
 
-pub const RuntimeError = error {
-	OutOfMemory,
-	InitFailure,
-	BadManifest,
-};
+fn kym_handle_errors(info: kym.ErrorInfo) void {
+	var remaining_frames = info.frames.len;
+
+	while (remaining_frames != 0) {
+		remaining_frames -= 1;
+
+		app.log_fail(info.frames[remaining_frames].name);
+	}
+}
+
+fn kym_log_info(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
+	app.log_info(try kym.unbox_string(env, try env.view_arg(0)));
+
+	return null;
+}
+
+fn kym_log_warn(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
+	app.log_warn(try kym.unbox_string(env, try env.view_arg(0)));
+
+	return null;
+}
+
+fn kym_log_fail(env: *kym.RuntimeEnv) kym.RuntimeError!?*kym.RuntimeRef {
+	app.log_fail(try kym.unbox_string(env, try env.view_arg(0)));
+
+	return null;
+}
 
 fn last_sdl_error() [:0]const u8 {
 	return coral.io.slice_sentineled(@as(u8, 0), @as([*:0]const u8, @ptrCast(ext.SDL_GetError())));
 }
 
-pub fn run_app(file_access: file.Access) RuntimeError!void {
-	var info_log = app.WritableLog.make(.info, heap.allocator);
-
-	defer info_log.free();
-
-	var fail_log = app.WritableLog.make(.fail, heap.allocator);
-
-	defer fail_log.free();
+pub fn run_app(file_access: file.Access) void {
+	defer heap.trace_leaks();
 
 	if (ext.SDL_Init(ext.SDL_INIT_EVERYTHING) != 0) {
-		try fail_log.write(last_sdl_error());
-
-		return error.InitFailure;
+		return app.log_fail(last_sdl_error());
 	}
 
 	defer ext.SDL_Quit();
 
-	var script_env = kym.RuntimeEnv.make(heap.allocator, .{
-		.out_writer = info_log.as_writer(),
-		.err_writer = fail_log.as_writer(),
-	}) catch {
-		try fail_log.write("failed to initialize script runtime");
-
-		return error.InitFailure;
+	var script_env = kym.RuntimeEnv.make(heap.allocator, kym.ErrorHandler.from(kym_handle_errors)) catch {
+		return app.log_fail("failed to initialize script runtime");
 	};
 
 	defer script_env.free();
 
+	script_env.bind_syscalls(&.{
+		.{
+			.name = "log_info",
+			.caller = kym.Caller.from(kym_log_info),
+		},
+		.{
+			.name = "log_fail",
+			.caller = kym.Caller.from(kym_log_fail),
+		},
+	}) catch {
+		return app.log_fail("failed to bind syscalls to script runtime");
+	};
+
 	var manifest = app.Manifest{};
 
-	manifest.load(&script_env, file_access) catch {
-		fail_log.write("failed to load / execute app.ona manifest") catch {};
-
-		return error.BadManifest;
-	};
+	manifest.load(&script_env, file_access) catch return;
 
 	const window = create: {
 		const pos = ext.SDL_WINDOWPOS_CENTERED;
 		const flags = 0;
 
 		break: create ext.SDL_CreateWindow(&manifest.title, pos, pos, manifest.width, manifest.height, flags) orelse {
-			fail_log.write(last_sdl_error()) catch {};
-
-			return error.InitFailure;
+			return app.log_fail(last_sdl_error());
 		};
 	};
 
 	defer ext.SDL_DestroyWindow(window);
 
 	const renderer = create: {
-		const defaultDriverIndex = -1;
+		const default_driver_index = -1;
 		const flags = ext.SDL_RENDERER_ACCELERATED;
 
-		break: create ext.SDL_CreateRenderer(window, defaultDriverIndex, flags) orelse {
-			fail_log.write(last_sdl_error()) catch {};
-
-			return error.InitFailure;
+		break: create ext.SDL_CreateRenderer(window, default_driver_index, flags) orelse {
+			return app.log_fail(last_sdl_error());
 		};
 	};
 

source/runner.zig

@@ -1,5 +1,5 @@
 const ona = @import("ona");
 
-pub fn main() ona.RuntimeError!void {
-	try ona.run_app(.{.sandboxed_path = &ona.file.Path.cwd});
+pub fn main() void {
+	ona.run_app(.{.sandboxed_path = &ona.file.Path.cwd});
 }