Refactor Kym runtime values to be objects
continuous-integration/drone/push Build is passing Details
continuous-integration/drone/pr Build is passing Details

This commit is contained in:
kayomn 2023-07-18 23:52:56 +01:00
parent 440d63447f
commit 1828eb3b45
10 changed files with 1117 additions and 769 deletions

View File

@ -223,6 +223,21 @@ pub fn copy(target: []Byte, source: []const Byte) void {
}
}
pub fn compare(this: []const Byte, that: []const Byte) isize {
const range = math.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;

View File

@ -16,6 +16,16 @@ pub fn Stack(comptime Value: type) type {
self.values = self.values[0 .. 0];
}
pub fn drop(self: *Self, amount: usize) bool {
if (amount > self.values.len) {
return false;
}
self.values = self.values[0 .. self.values.len - amount];
return true;
}
pub fn free(self: *Self) void {
if (self.capacity == 0) {
return;
@ -49,6 +59,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;

View File

@ -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,
@ -143,6 +160,25 @@ pub fn Table(comptime Key: type, comptime Value: type, comptime traits: TableTra
const Self = @This();
pub fn remove(self: *Self, key: Key) ?Entry {
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);
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);

View File

@ -12,39 +12,53 @@ pub const Manifest = struct {
height: u16 = 480,
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"}));
pub fn load(self: *Manifest, env: *kym.RuntimeEnv, global_ref: ?*const kym.RuntimeRef, file_access: file.Access) kym.RuntimeError!void {
var manifest_ref = try env.execute_file(global_ref, file_access, file.Path.from(&.{"app.ona"}));
defer env.discard(manifest);
defer env.discard(&manifest_ref);
const title = try env.get_field(manifest, "title");
var title_ref = try kym.get_dynamic_field(env, manifest_ref, "title");
defer env.discard(title);
defer env.discard(&title_ref);
const title_string = try env.get_string(title);
const title_string = switch (env.unbox(title_ref)) {
.string => |string| string,
else => "",
};
const width = @as(u16, get: {
const ref = try env.get_field(manifest, "width");
var ref = try kym.get_dynamic_field(env, manifest_ref, "width");
defer env.discard(ref);
defer env.discard(&ref);
break: get @intFromFloat(env.get_float(ref) catch @as(f64, @floatFromInt(self.width)));
// TODO: Add safety-checks to int cast.
break: get switch (env.unbox(ref)) {
.number => |number| @intFromFloat(number),
else => self.width,
};
});
const height = @as(u16, get: {
const ref = try env.get_field(manifest, "height");
var ref = try kym.get_dynamic_field(env, manifest_ref, "height");
defer env.discard(ref);
defer env.discard(&ref);
break: get @intFromFloat(env.get_float(ref) catch @as(f64, @floatFromInt(self.height)));
// TODO: Add safety-checks to int cast.
break: get switch (env.unbox(ref)) {
.number => |number| @intFromFloat(number),
else => self.height,
};
});
const tick_rate = @as(f32, get: {
const ref = try env.get_field(manifest, "tick_rate");
var ref = try kym.get_dynamic_field(env, manifest_ref, "tick_rate");
defer env.discard(ref);
defer env.discard(&ref);
break: get @floatCast(env.get_float(ref) catch self.tick_rate);
break: get switch (env.unbox(ref)) {
.number => |number| @floatCast(number),
else => self.tick_rate,
};
});
{

View File

@ -1,6 +1,6 @@
const Ast = @import("./kym/Ast.zig");
const State = @import("./kym/State.zig");
const Chunk = @import("./kym/Chunk.zig");
const Table = @import("./kym/Table.zig");
@ -12,10 +12,9 @@ const tokens = @import("./kym/tokens.zig");
pub const CallContext = struct {
env: *RuntimeEnv,
caller: *const RuntimeRef,
callable: *const RuntimeRef,
caller: ?*const RuntimeRef,
userdata: []u8,
args: []const *const RuntimeRef = &.{},
args: []const ?*const RuntimeRef = &.{},
pub fn arg_at(self: CallContext, index: u8) RuntimeError!*const RuntimeRef {
if (!coral.math.is_clamped(index, 0, self.args.len - 1)) {
@ -26,408 +25,106 @@ pub const CallContext = struct {
}
};
const Compiler = struct {
state: *State,
opcodes: OpcodeList,
locals: struct {
buffer: [255][]const coral.io.Byte = [_][]const coral.io.Byte{""} ** 255,
count: u8 = 0,
const Self = @This();
fn declare(self: *Self, identifier: []const u8) CompileError!void {
if (self.count == self.buffer.len) {
return error.TooManyLocals;
}
self.buffer[self.count] = identifier;
self.count += 1;
}
fn resolve(self: *Self, local_identifier: []const coral.io.Byte) ?u8 {
if (self.count == 0) {
return null;
}
var index = @as(u8, self.count - 1);
while (true) : (index -= 1) {
if (coral.io.equals(local_identifier, self.buffer[index])) {
return index;
}
if (index == 0) {
return null;
}
}
}
},
const CompileError = coral.io.AllocationError || error {
UndefinedLocal,
TooManyLocals,
pub const DynamicObject = struct {
userdata: []coral.io.Byte,
typeinfo: *const Typeinfo,
};
const LocalsList = coral.list.Stack([]const u8);
const OpcodeList = coral.list.Stack(Opcode);
fn compile_ast(self: *Compiler, ast: Ast) CompileError!void {
for (ast.list_statements()) |statement| {
switch (statement) {
.return_expression => |return_expression| {
try self.compile_expression(return_expression);
},
.return_nothing => {
try self.opcodes.push_one(.push_nil);
},
.set_local => |local| {
try self.compile_expression(local.expression);
if (self.locals.resolve(local.identifier)) |index| {
try self.opcodes.push_one(.{.set_local = index});
} else {
try self.locals.declare(local.identifier);
}
},
}
}
}
fn compile_expression(self: *Compiler, expression: Ast.Expression) CompileError!void {
const is_zero = struct {
fn is_zero(utf8: []const u8) bool {
return coral.io.equals(utf8, "0") or coral.io.equals(utf8, "0.0");
}
}.is_zero;
const number_format = coral.utf8.DecimalFormat{
.delimiter = "_",
.positive_prefix = .none,
};
switch (expression) {
.nil_literal => try self.opcodes.push_one(.push_nil),
.true_literal => try self.opcodes.push_one(.push_true),
.false_literal => try self.opcodes.push_one(.push_false),
.number_literal => |literal| {
const parsed_number = number_format.parse(literal, State.Float);
coral.debug.assert(parsed_number != null);
try self.opcodes.push_one(if (is_zero(literal)) .push_zero else .{.push_number = parsed_number.?});
},
.string_literal => |literal| {
try self.opcodes.push_one(.{
.push_object = try self.state.acquire_interned(literal, &string_info),
});
},
.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.opcodes.push_one(.{
.push_object = try self.state.acquire_interned(field.identifier, &string_info),
});
}
try self.opcodes.push_one(.{.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.opcodes.push_one(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.opcodes.push_one(switch (operation.operator) {
.boolean_negation => .not,
.numeric_negation => .neg,
});
},
.grouped_expression => |grouped_expression| {
try self.compile_expression(grouped_expression.*);
},
.get_local => |local| {
try self.opcodes.push_one(.{
.get_local = self.locals.resolve(local) orelse return error.UndefinedLocal,
});
},
}
}
fn free(self: *Compiler) void {
for (self.opcodes.values) |opcode| {
if (opcode == .push_object) {
self.state.release(opcode.push_object);
}
}
self.opcodes.free();
}
fn list_opcodes(self: Compiler) []const Opcode {
return self.opcodes.values;
}
fn make(allocator: coral.io.Allocator, state: *State) Compiler {
return .{
.locals = .{},
.opcodes = OpcodeList.make(allocator),
.state = state,
};
}
};
pub const Float = f64;
pub const IndexContext = struct {
env: *RuntimeEnv,
indexable: *const RuntimeRef,
index: *const RuntimeRef,
userdata: []u8,
};
pub const ObjectInfo = struct {
call: *const fn (context: CallContext) RuntimeError!*RuntimeRef = default_call,
clean: *const fn (userdata: []u8) void = default_clean,
get: *const fn (context: IndexContext) RuntimeError!*RuntimeRef = default_get,
set: *const fn (context: IndexContext, value: *const RuntimeRef) RuntimeError!void = default_set,
fn cast(object_info: *const anyopaque) *const ObjectInfo {
return @ptrCast(@alignCast(object_info));
}
fn default_call(context: CallContext) RuntimeError!*RuntimeRef {
return context.env.raise(error.BadOperation, "attempt to call non-callable");
}
fn default_clean(_: []u8) void {
// Nothing to clean up by default.
}
fn default_get(context: IndexContext) RuntimeError!*RuntimeRef {
return context.env.raise(error.BadOperation, "attempt to get non-indexable");
}
fn default_set(context: IndexContext, _: *const RuntimeRef) RuntimeError!void {
return context.env.raise(error.BadOperation, "attempt to set non-indexable");
}
};
pub const Opcode = union (enum) {
push_nil,
push_true,
push_false,
push_zero,
push_number: State.Float,
push_table: u32,
push_object: *State.Object,
set_local: u8,
get_local: u8,
not,
neg,
add,
sub,
mul,
div,
eql,
cgt,
clt,
cge,
cle,
userdata: []coral.io.Byte,
index_ref: ?*const RuntimeRef,
};
pub const RuntimeEnv = struct {
allocator: coral.io.Allocator,
err_writer: coral.io.Writer,
bound_refs: VariantSlab,
state: State,
local_refs: RefStack,
frames: FrameStack,
ref_values: RefSlab,
const FrameStack = coral.list.Stack(struct {
locals_top: usize,
});
const RefStack = coral.list.Stack(?*RuntimeRef);
pub const Options = struct {
out_writer: coral.io.Writer = coral.io.null_writer,
err_writer: coral.io.Writer = coral.io.null_writer,
};
const RefSlab = coral.map.Slab(struct {
ref_count: usize,
object: union (enum) {
false,
true,
number: Float,
string: []coral.io.Byte,
dynamic: *DynamicObject,
},
});
pub const ScriptSource = struct {
name: []const coral.io.Byte,
data: []const coral.io.Byte,
};
const VariantSlab = coral.map.Slab(State.Variant);
pub fn acquire(self: *RuntimeEnv, ref: ?*const RuntimeRef) ?*RuntimeRef {
const key = @intFromPtr(ref);
var ref_data = self.ref_values.remove(key);
pub fn discard(self: *RuntimeEnv, ref: *RuntimeRef) void {
coral.debug.assert(self.bound_refs.remove(@intFromPtr(ref)) != null);
coral.debug.assert(ref_data != null);
ref_data.?.ref_count += 1;
coral.debug.assert(self.ref_values.insert_at(key, ref_data.?));
return @ptrFromInt(key);
}
pub fn execute_chunk(self: *RuntimeEnv, name: []const coral.io.Byte, opcodes: []const Opcode) RuntimeError!*RuntimeRef {
_ = name;
pub fn call(
self: *RuntimeEnv,
caller_ref: *const RuntimeRef,
callable_ref: *const RuntimeRef,
arg_refs: []const *const RuntimeRef,
) RuntimeError!*RuntimeRef {
const callable = (try callable_ref.fetch(self)).to_object();
for (opcodes) |opcode| {
switch (opcode) {
.push_nil => try self.state.push_value(.nil),
.push_true => try self.state.push_value(.true),
.push_false => try self.state.push_value(.false),
.push_zero => try self.state.push_value(.{.number = 0}),
.push_number => |number| try self.state.push_value(.{.number = number}),
.push_table => |size| {
var table = Table.make(self.allocator, &self.state);
errdefer table.free();
{
var popped = @as(usize, 0);
while (popped < size) : (popped += 1) {
try table.set_field(
try to_object(self, try self.state.pop_value()),
try self.state.pop_value());
}
}
const table_object = try self.state.acquire_new(coral.io.bytes_of(&table), &table_info);
errdefer self.state.release(table_object);
try self.state.push_value(.{.object = table_object});
},
.push_object => |object| {
const acquired_object = self.state.acquire_instance(object);
errdefer self.state.release(acquired_object);
try self.state.push_value(.{.object = acquired_object});
},
.set_local => |local| {
if (!self.state.set_value(local, try self.state.pop_value())) {
return self.raise(error.BadOperation, "invalid local set");
}
},
.get_local => |local| {
try self.state.push_value(self.state.get_value(local));
},
.not => {
try self.state.push_value(switch (try self.state.pop_value()) {
.nil => return self.raise(error.BadOperation, "cannot convert nil to true or false"),
.false => .true,
.true => .false,
.number => return self.raise(error.BadOperation, "cannot convert a number to true or false"),
.object => return self.raise(error.BadOperation, "cannot convert an object to true or false"),
return callable.userinfo.call(.{
.env = self,
.caller = caller_ref,
.callable = callable_ref,
.userdata = callable.userdata,
.args = arg_refs,
});
},
.neg => {
try self.state.push_value(.{.number = -(try to_number(self, try self.state.pop_value()))});
},
.add => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(.{.number = lhs_number + rhs_number});
},
.sub => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(.{.number = lhs_number - rhs_number});
},
.mul => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(.{.number = lhs_number * rhs_number});
},
.div => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(.{.number = lhs_number / rhs_number});
},
.eql => {
const rhs = try self.state.pop_value();
const lhs = try self.state.pop_value();
try self.state.push_value(if (lhs.equals(rhs)) .true else .false);
},
.cgt => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(if (lhs_number > rhs_number) .true else .false);
},
.clt => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(if (lhs_number < rhs_number) .true else .false);
},
.cge => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(if (lhs_number >= rhs_number) .true else .false);
},
.cle => {
const rhs_number = try to_number(self, try self.state.pop_value());
const lhs_number = try to_number(self, try self.state.pop_value());
try self.state.push_value(if (lhs_number <= rhs_number) .true else .false);
},
}
}
const return_value = try self.state.pop_value();
pub fn discard(self: *RuntimeEnv, ref: *?*RuntimeRef) void {
const key = @intFromPtr(ref.* orelse return);
var ref_data = self.ref_values.remove(key) orelse unreachable;
errdefer if (return_value == .object) {
self.state.release(return_value.object);
};
coral.debug.assert(ref_data.ref_count != 0);
return @ptrFromInt(try self.bound_refs.insert(return_value));
ref_data.ref_count -= 1;
if (ref_data.ref_count == 0) {
switch (ref_data.object) {
.string => |string| self.allocator.deallocate(string),
.dynamic => |virtual| self.allocator.deallocate(virtual),
else => {},
}
} else {
coral.debug.assert(self.ref_values.insert_at(key, ref_data));
}
pub fn execute_file(self: *RuntimeEnv, file_access: file.Access, file_path: file.Path) RuntimeError!*RuntimeRef {
ref.* = null;
}
pub fn execute_file(self: *RuntimeEnv, global_ref: ?*const RuntimeRef, file_access: file.Access, file_path: file.Path) RuntimeError!?*RuntimeRef {
const error_message = "failed to load file";
const file_data = (try file.allocate_and_load(self.allocator, file_access, file_path)) orelse {
@ -436,13 +133,13 @@ pub const RuntimeEnv = struct {
defer self.allocator.deallocate(file_data);
return self.execute_script(.{
return self.execute_script(global_ref, .{
.name = file_path.to_string() orelse return self.raise(error.SystemFailure, error_message),
.data = file_data,
});
}
pub fn execute_script(self: *RuntimeEnv, source: ScriptSource) RuntimeError!*RuntimeRef {
pub fn execute_script(self: *RuntimeEnv, global_ref: ?*const RuntimeRef, source: ScriptSource) RuntimeError!?*RuntimeRef {
var ast = Ast.make(self.allocator);
defer ast.free();
@ -456,198 +153,271 @@ pub const RuntimeEnv = struct {
};
}
var compiler = Compiler.make(self.allocator, &self.state);
var exe = Chunk.make(self);
defer compiler.free();
defer exe.free();
compiler.compile_ast(ast) catch |compile_error| return switch (compile_error) {
error.OutOfMemory => error.OutOfMemory,
error.UndefinedLocal => self.raise(error.BadOperation, "use of undefined local"),
error.TooManyLocals => self.raise(error.OutOfMemory, "functions cannot contain more than 255 locals"),
};
try exe.compile_ast(ast);
return self.execute_chunk(source.name, compiler.list_opcodes());
return exe.execute(global_ref, source.name);
}
pub fn free(self: *RuntimeEnv) void {
self.bound_refs.free();
self.state.free();
pub fn frame_pop(self: *RuntimeEnv) RuntimeError!void {
const frame = self.frames.pop() orelse return self.raise(error.IllegalState, "stack underflow");
coral.debug.assert(self.local_refs.drop(self.local_refs.values.len - frame.locals_top));
}
pub fn get_field(self: *RuntimeEnv, indexable: *const RuntimeRef, field: []const u8) RuntimeError!*RuntimeRef {
const interned_field = try self.intern(field);
defer self.discard(interned_field);
const indexable_object = try to_object(self, try indexable.fetch(self));
return ObjectInfo.cast(indexable_object.userinfo).get(.{
.env = self,
.indexable = indexable,
.index = interned_field,
.userdata = indexable_object.userdata,
pub fn frame_push(self: *RuntimeEnv) RuntimeError!void {
return self.frames.push_one(.{
.locals_top = self.local_refs.values.len,
});
}
pub fn get_float(self: *RuntimeEnv, ref: *const RuntimeRef) RuntimeError!State.Float {
return to_number(self, try ref.fetch(self));
pub fn free(self: *RuntimeEnv) void {
self.local_refs.free();
self.ref_values.free();
}
pub fn get_string(self: *RuntimeEnv, ref: *const RuntimeRef) RuntimeError![]const u8 {
const object = try to_object(self, try ref.fetch(self));
pub fn get_dynamic(self: *RuntimeEnv, indexable_ref: ?*const RuntimeRef, index_ref: ?*const RuntimeRef) RuntimeError!?*RuntimeRef {
return switch (self.unbox(indexable_ref)) {
.nil => self.raise(error.BadOperation, "nil is immutable"),
.boolean => self.raise(error.BadOperation, "boolean has no such index"),
.number => self.raise(error.BadOperation, "number has no such index"),
.string => self.raise(error.BadOperation, "string has no such index"),
if (ObjectInfo.cast(object.userinfo) != &string_info) {
return self.raise(error.BadOperation, "object is not a string");
.dynamic => |dynamic| dynamic.typeinfo.get(.{
.userdata = dynamic.userdata,
.env = self,
.index_ref = index_ref,
}),
};
}
return object.userdata;
pub fn local_get(self: *RuntimeEnv, local: u8) RuntimeError!?*RuntimeRef {
return self.local_refs.values[local];
}
pub fn intern(self: *RuntimeEnv, data: []const u8) RuntimeError!*RuntimeRef {
const data_object = try self.state.acquire_interned(data, &string_info);
pub fn local_pop(self: *RuntimeEnv) RuntimeError!?*RuntimeRef {
return self.local_refs.pop() orelse self.raise(error.IllegalState, "stack underflow");
}
errdefer self.state.release(data_object);
pub fn local_push_ref(self: *RuntimeEnv, ref: ?*RuntimeRef) RuntimeError!void {
return self.local_refs.push_one(self.acquire(ref));
}
return @ptrFromInt(try self.bound_refs.insert(.{.object = data_object}));
pub fn local_push_boolean(self: *RuntimeEnv, boolean: bool) RuntimeError!void {
return self.local_refs.push_one(try self.new_boolean(boolean));
}
pub fn local_push_number(self: *RuntimeEnv, number: Float) RuntimeError!void {
return self.local_refs.push_one(try self.new_number(number));
}
pub fn local_set(self: *RuntimeEnv, local: u8, value: ?*RuntimeRef) RuntimeError!void {
self.local_refs.values[local] = self.acquire(value);
}
pub fn make(allocator: coral.io.Allocator, options: Options) RuntimeError!RuntimeEnv {
var env = RuntimeEnv{
.allocator = allocator,
.bound_refs = VariantSlab.make(allocator),
.state = State.make(allocator),
return .{
.local_refs = RefStack.make(allocator),
.ref_values = RefSlab.make(allocator),
.frames = FrameStack.make(allocator),
.err_writer = options.err_writer,
.allocator = allocator,
};
return env;
}
pub fn new_object(self: *RuntimeEnv, userdata: []const u8, info: *const ObjectInfo) RuntimeError!*RuntimeRef {
const data_object = try self.state.acquire_new(userdata, info);
defer self.state.release(data_object);
return @ptrFromInt(try self.bound_refs.insert(.{.object = data_object}));
pub fn new_boolean(self: *RuntimeEnv, value: bool) RuntimeError!?*RuntimeRef {
return @ptrFromInt(try self.ref_values.insert(.{
.ref_count = 1,
.object = if (value) .true else .false,
}));
}
pub fn raise(self: *RuntimeEnv, runtime_error: RuntimeError, error_message: []const u8) RuntimeError {
pub fn new_dynamic(self: *RuntimeEnv, userdata: []const coral.io.Byte, typeinfo: *const Typeinfo) RuntimeError!*RuntimeRef {
const userdata_copy = try coral.io.allocate_copy(self.allocator, userdata);
errdefer self.allocator.deallocate(userdata_copy);
const dynamic_object = try coral.io.allocate_one(self.allocator, DynamicObject{
.typeinfo = typeinfo,
.userdata = userdata_copy,
});
errdefer self.allocator.deallocate(dynamic_object);
return @ptrFromInt(try self.ref_values.insert(.{
.ref_count = 1,
.object = .{.dynamic = dynamic_object},
}));
}
pub fn new_number(self: *RuntimeEnv, value: Float) RuntimeError!?*RuntimeRef {
return @ptrFromInt(try self.ref_values.insert(.{
.ref_count = 1,
.object = .{.number = value},
}));
}
pub fn new_string(self: *RuntimeEnv, string_data: []const coral.io.Byte) RuntimeError!?*RuntimeRef {
const string_copy = try coral.io.allocate_copy(self.allocator, string_data);
errdefer self.allocator.deallocate(string_copy);
return @ptrFromInt(try self.ref_values.insert(.{
.ref_count = 1,
.object = .{.string = string_copy},
}));
}
pub fn raise(self: *RuntimeEnv, error_value: RuntimeError, error_message: []const u8) RuntimeError {
// TODO: Print stack trace from state.
coral.utf8.print_formatted(self.err_writer, "{name}@{line}: {message}", .{
.name = "???",
.line = @as(u64, 0),
.message = error_message,
}) catch return error.SystemFailure;
}) catch {};
return runtime_error;
return error_value;
}
pub fn set_dynamic(self: *RuntimeEnv, indexable_ref: ?*const RuntimeRef, index_ref: ?*const RuntimeRef, value_ref: ?*const RuntimeRef) RuntimeError!void {
return switch (self.unbox(indexable_ref)) {
.nil => self.raise(error.BadOperation, "nil is immutable"),
.boolean => self.raise(error.BadOperation, "boolean is immutable"),
.number => self.raise(error.BadOperation, "number is immutable"),
.string => self.raise(error.BadOperation, "string is immutable"),
.dynamic => |dynamic| dynamic.typeinfo.set(.{
.userdata = dynamic.userdata,
.env = self,
.index_ref = index_ref,
}, value_ref),
};
}
pub fn unbox(self: *RuntimeEnv, ref: ?*const RuntimeRef) Unboxed {
const ref_data = self.ref_values.lookup(@intFromPtr(ref orelse return .nil));
coral.debug.assert(ref_data != null);
return switch (ref_data.?.object) {
.false => .{.boolean = false},
.true => .{.boolean = true},
.number => |number| .{.number = number},
.string => |string| .{.string = string},
.dynamic => |dynamic| .{.dynamic = dynamic},
};
}
};
pub const RuntimeError = coral.io.AllocationError || State.PopError || error {
BadSyntax,
BadOperation,
pub const RuntimeError = coral.io.AllocationError || error {
IllegalState,
SystemFailure,
TypeMismatch,
BadOperation,
BadSyntax,
};
pub const RuntimeRef = opaque {
fn fetch(self: *const RuntimeRef, env: *RuntimeEnv) RuntimeError!State.Variant {
return env.bound_refs.lookup(@intFromPtr(self)) orelse env.raise(error.BadOperation, "stale ref");
pub const RuntimeRef = opaque {};
pub const TestContext = struct {
env: *RuntimeEnv,
userdata: []const coral.io.Byte,
other_ref: ?*const RuntimeRef,
};
pub const Typeinfo = struct {
call: *const fn (context: CallContext) RuntimeError!?*RuntimeRef,
clean: *const fn (userdata: []u8) void,
get: *const fn (context: IndexContext) RuntimeError!?*RuntimeRef,
set: *const fn (context: IndexContext, value: ?*const RuntimeRef) RuntimeError!void,
test_difference: *const fn (context: TestContext) RuntimeError!Float = default_test_difference,
test_equality: *const fn (context: TestContext) RuntimeError!bool = default_test_equality,
fn default_test_difference(context: TestContext) RuntimeError!Float {
return context.env.raise(error.TypeMismatch, "object is not comparable");
}
fn default_test_equality(context: TestContext) RuntimeError!bool {
return switch (context.env.unbox(context.other_ref)) {
.dynamic => |dynamic| context.userdata.ptr == dynamic.userdata.ptr,
else => false,
};
}
};
fn table_clean(userdata: []u8) void {
@as(*Table, @ptrCast(@alignCast(userdata.ptr))).free();
}
fn table_get(context: IndexContext) RuntimeError!*RuntimeRef {
const table = @as(*Table, @ptrCast(@alignCast(context.userdata.ptr)));
switch (try context.index.fetch(context.env)) {
.nil => return context.env.raise(error.BadOperation, "cannot index a table with nil"),
.true => return context.env.raise(error.BadOperation, "cannot index a table with true"),
.false => return context.env.raise(error.BadOperation, "cannot index a table with false"),
.object => |index_object| {
const value = table.get_field(index_object);
errdefer if (value == .object) {
context.env.state.release(value.object);
pub const Unboxed = union (enum) {
nil,
boolean: bool,
number: Float,
string: []const u8,
dynamic: *const DynamicObject,
};
return @ptrFromInt(try context.env.bound_refs.insert(value));
pub fn get_dynamic_field(env: *RuntimeEnv, indexable: ?*const RuntimeRef, field: []const u8) RuntimeError!?*RuntimeRef {
var interned_field = try env.new_string(field);
defer env.discard(&interned_field);
return env.get_dynamic(indexable, interned_field);
}
pub fn new_table(env: *RuntimeEnv) RuntimeError!?*RuntimeRef {
var table = Table.make(env);
errdefer table.free();
return try env.new_dynamic(coral.io.bytes_of(&table), &Table.typeinfo);
}
pub fn test_difference(env: *RuntimeEnv, lhs_ref: ?*const RuntimeRef, rhs_ref: ?*const RuntimeRef) RuntimeError!Float {
return switch (env.unbox(lhs_ref)) {
.nil => env.raise(error.TypeMismatch, "cannot compare nil objects"),
.boolean => env.raise(error.TypeMismatch, "cannot compare boolean objects"),
.number => |lhs_number| switch (env.unbox(rhs_ref)) {
.number => |rhs_number| rhs_number - lhs_number,
else => env.raise(error.TypeMismatch, "right-hand object is not comparable with number objects"),
},
.number => |index_number| {
const value = table.get_index(@intFromFloat(index_number));
errdefer if (value == .object) {
context.env.state.release(value.object);
};
return @ptrFromInt(try context.env.bound_refs.insert(value));
},
}
}
const table_info = ObjectInfo{
.clean = table_clean,
.get = table_get,
.set = table_set,
};
fn table_set(context: IndexContext, value: *const RuntimeRef) RuntimeError!void {
const table = @as(*Table, @ptrCast(@alignCast(context.userdata.ptr)));
switch (try context.index.fetch(context.env)) {
.nil => return context.env.raise(error.BadOperation, "cannot index a table with nil"),
.true => return context.env.raise(error.BadOperation, "cannot index a table with true"),
.false => return context.env.raise(error.BadOperation, "cannot index a table with false"),
.object => |index_object| {
const fetched_value = try value.fetch(context.env);
if (fetched_value == .object) {
try table.set_field(index_object, .{
.object = context.env.state.acquire_instance(fetched_value.object),
});
} else {
try table.set_field(index_object, fetched_value);
}
.string => |lhs_string| switch (env.unbox(rhs_ref)) {
.string => |rhs_string| @floatFromInt(coral.io.compare(lhs_string, rhs_string)),
else => env.raise(error.TypeMismatch, "right-hand object is not comparable with string objects"),
},
.number => |index_number| {
const fetched_value = try value.fetch(context.env);
if (fetched_value == .object) {
try table.set_index(@intFromFloat(index_number), .{
.object = context.env.state.acquire_instance(fetched_value.object),
});
} else {
try table.set_index(@intFromFloat(index_number), fetched_value);
.dynamic => |lhs_dynamic| lhs_dynamic.typeinfo.test_difference(.{
.env = env,
.userdata = lhs_dynamic.userdata,
.other_ref = rhs_ref,
}),
};
}
pub fn test_equality(env: *RuntimeEnv, lhs_ref: ?*const RuntimeRef, rhs_ref: ?*const RuntimeRef) RuntimeError!bool {
return switch (env.unbox(lhs_ref)) {
.nil => (rhs_ref == null),
.boolean => |lhs_boolean| switch (env.unbox(rhs_ref)) {
.boolean => |rhs_boolean| rhs_boolean == lhs_boolean,
else => false,
},
}
}
fn to_number(env: *RuntimeEnv, variant: State.Variant) RuntimeError!State.Float {
return switch (variant) {
.nil => env.raise(error.BadOperation, "cannot convert nil to number"),
.true => env.raise(error.BadOperation, "cannot convert true to number"),
.false => env.raise(error.BadOperation, "cannot convert false to number"),
.number => |number| number,
.object => env.raise(error.BadOperation, "cannot convert object to number"),
.number => |lhs_number| switch (env.unbox(rhs_ref)) {
.number => |rhs_number| lhs_number == rhs_number,
else => false,
},
.string => |lhs_string| switch (env.unbox(rhs_ref)) {
.string => |rhs_string| coral.io.equals(lhs_string, rhs_string),
else => false,
},
.dynamic => |lhs_dynamic| try lhs_dynamic.typeinfo.test_equality(.{
.env = env,
.userdata = lhs_dynamic.userdata,
.other_ref = rhs_ref,
}),
};
}
fn to_object(env: *RuntimeEnv, variant: State.Variant) RuntimeError!*State.Object {
return switch (variant) {
.nil => env.raise(error.BadOperation, "cannot convert nil to object"),
.true => env.raise(error.BadOperation, "cannot convert true to object"),
.false => env.raise(error.BadOperation, "cannot convert false to object"),
.number => env.raise(error.BadOperation, "cannot convert number to object"),
.object => |object| object,
};
}
const string_info = ObjectInfo{
};

View File

@ -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_global: 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_global: 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) {
@ -181,8 +195,6 @@ pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!void {
.local => |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 {
}
},
.global => |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_global = .{
.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,6 +333,48 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression
return Expression{.string_literal = value};
},
.global => |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_global = .{
.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_global = .{
.identifier = identifier,
.argument_expressions = expression_list,
},
};
},
else => return self.raise("expected `,` or `)` after argument"),
}
},
}
}
},
.local => |identifier| {
tokenizer.step();

504
source/ona/kym/Chunk.zig Normal file
View File

@ -0,0 +1,504 @@
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 = .{.field_count = @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(.{
.local_push_ref = self.resolve_local(local) orelse return self.chunk.env.raise(error.OutOfMemory, "undefined local"),
});
},
.call_global => |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(.{
.global_call = .{
.arg_count = @intCast(call.argument_expressions.values.len),
},
});
},
}
}
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_global => |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(.{
.global_call = .{
.arg_count = @intCast(call.argument_expressions.values.len),
},
});
}
}
}
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) {
push_nil,
push_true,
push_false,
push_const: Constant,
local_push_ref: u8,
set_local: u8,
get_global,
push_table: struct {
field_count: u32,
},
global_call: struct {
arg_count: 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 compile_ast(self: *Self, ast: Ast) kym.RuntimeError!void {
self.free();
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");
}
var 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");
}
var 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);
}
pub fn execute(self: *Self, global_ref: ?*const kym.RuntimeRef, name: []const coral.io.Byte) kym.RuntimeError!?*kym.RuntimeRef {
_ = name;
try self.env.frame_push();
for (self.opcodes.values) |opcode| {
switch (opcode) {
.push_nil => try self.env.local_push_ref(null),
.push_true => try self.env.local_push_boolean(true),
.push_false => try self.env.local_push_boolean(false),
.push_const => |constant| try self.env.local_push_ref(self.constant_refs.values[constant]),
.push_table => |push_table| {
var table_ref = try kym.new_table(self.env);
defer self.env.discard(&table_ref);
{
var popped = @as(usize, 0);
while (popped < push_table.field_count) : (popped += 1) {
try self.env.set_dynamic(table_ref, try self.env.local_pop(), try self.env.local_pop());
}
}
try self.env.local_push_ref(table_ref);
},
.local_push_ref => |local| {
var ref = try self.env.local_get(local);
defer self.env.discard(&ref);
try self.env.local_push_ref(ref);
},
.get_global => {
var identifier_ref = try self.env.local_pop();
defer self.env.discard(&identifier_ref);
var ref = try self.env.get_dynamic(global_ref, identifier_ref);
defer self.env.discard(&ref);
try self.env.local_push_ref(ref);
},
.set_local => |local| {
var ref = try self.env.local_pop();
defer self.env.discard(&ref);
try self.env.local_set(local, ref);
},
.global_call => |_| {
},
.neg => try self.env.local_push_number(switch (self.env.unbox(try self.env.local_pop())) {
.number => |number| -number,
else => return self.env.raise(error.TypeMismatch, "object is not scalar negatable"),
}),
.not => try self.env.local_push_boolean(switch (self.env.unbox(try self.env.local_pop())) {
.boolean => |boolean| !boolean,
else => return self.env.raise(error.TypeMismatch, "object is not boolean negatable"),
}),
.add => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_ref(switch (self.env.unbox(lhs_ref)) {
.number => |lhs_number| switch (self.env.unbox(rhs_ref)) {
.number => |rhs_number| try self.env.new_number(lhs_number + rhs_number),
else => return self.env.raise(error.TypeMismatch, "right-hand object is not addable"),
},
else => return self.env.raise(error.TypeMismatch, "left-hand object is not addable"),
});
},
.sub => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_ref(switch (self.env.unbox(lhs_ref)) {
.number => |lhs_number| switch (self.env.unbox(rhs_ref)) {
.number => |rhs_number| try self.env.new_number(lhs_number - rhs_number),
else => return self.env.raise(error.TypeMismatch, "right-hand object is not subtractable"),
},
else => return self.env.raise(error.TypeMismatch, "left-hand object is not subtractable"),
});
},
.mul => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_ref(switch (self.env.unbox(lhs_ref)) {
.number => |lhs_number| switch (self.env.unbox(rhs_ref)) {
.number => |rhs_number| try self.env.new_number(lhs_number * rhs_number),
else => return self.env.raise(error.TypeMismatch, "right-hand object is not multiplyable"),
},
else => return self.env.raise(error.TypeMismatch, "left-hand object is not multiplyable"),
});
},
.div => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_ref(switch (self.env.unbox(lhs_ref)) {
.number => |lhs_number| switch (self.env.unbox(rhs_ref)) {
.number => |rhs_number| try self.env.new_number(lhs_number / rhs_number),
else => return self.env.raise(error.TypeMismatch, "right-hand object is not divisable"),
},
else => return self.env.raise(error.TypeMismatch, "left-hand object is not divisable"),
});
},
.eql => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_boolean(try kym.test_equality(self.env, lhs_ref, rhs_ref));
},
.cgt => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_boolean(try kym.test_difference(self.env, lhs_ref, rhs_ref) > 0);
},
.clt => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_boolean(try kym.test_difference(self.env, lhs_ref, rhs_ref) < 0);
},
.cge => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_boolean(try kym.test_difference(self.env, lhs_ref, rhs_ref) >= 0);
},
.cle => {
var rhs_ref = try self.env.local_pop();
defer self.env.discard(&rhs_ref);
var lhs_ref = try self.env.local_pop();
defer self.env.discard(&lhs_ref);
try self.env.local_push_boolean(try kym.test_difference(self.env, lhs_ref, rhs_ref) <= 0);
},
}
}
const result = try self.env.local_pop();
try self.env.frame_pop();
return result;
}
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,
};
}

View File

@ -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;
}

View File

@ -1,76 +1,82 @@
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.Table([]const coral.io.Byte, struct {
key_ref: ?*kym.RuntimeRef,
value_ref: ?*kym.RuntimeRef,
}, coral.map.string_table_traits);
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);
}
}
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;
}
pub fn get_index(self: *Self, index: usize) State.Variant {
return self.array.values[index];
}
pub fn make(allocator: coral.io.Allocator, state: *State) Self {
pub fn make(env: *kym.RuntimeEnv) Self {
return .{
.state = state,
.fields = FieldTable.make(allocator),
.array = ArrayList.make(allocator),
.fields = FieldTable.make(env.allocator),
};
}
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,
});
pub const typeinfo = kym.Typeinfo{
.call = typeinfo_call,
.clean = typeinfo_clean,
.get = typeinfo_get,
.set = typeinfo_set,
};
if (previous_entry) |entry| {
entry.value.release_objects(self.state);
}
fn typeinfo_call(context: kym.CallContext) kym.RuntimeError!?*kym.RuntimeRef {
return context.env.raise(error.TypeMismatch, "cannot call a table");
}
pub fn set_index(self: *Self, index: usize, value: State.Variant) coral.io.AllocationError!void {
self.array.values[index] = value;
fn typeinfo_clean(userdata: []u8) void {
@as(*Self, @ptrCast(@alignCast(userdata.ptr))).free();
}
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"),
};
}
fn typeinfo_set(context: kym.IndexContext, value_ref: ?*const kym.RuntimeRef) kym.RuntimeError!void {
const table = @as(*Self, @ptrCast(@alignCast(context.userdata.ptr)));
var acquired_value_ref = context.env.acquire(value_ref);
errdefer context.env.discard(&acquired_value_ref);
switch (context.env.unbox(context.index_ref)) {
.string => |string| {
var 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");
},
}
}

View File

@ -48,9 +48,17 @@ pub fn run_app(file_access: file.Access) RuntimeError!void {
defer script_env.free();
var globals_ref = kym.new_table(&script_env) catch {
try fail_log.write("failed to initialize script runtime");
return error.InitFailure;
};
defer script_env.discard(&globals_ref);
var manifest = app.Manifest{};
manifest.load(&script_env, file_access) catch {
manifest.load(&script_env, globals_ref, file_access) catch {
fail_log.write("failed to load / execute app.ona manifest") catch {};
return error.BadManifest;