kayomn
/
ona
1
0
Fork 0
Code Issues 8 Pull Requests Projects 4 Releases Activity

Implement Bytecode Executor for Kym #19

Merged
kayomn merged 9 commits from kym-bytecode-executor into main 2023-07-12 02:58:03 +02:00
Conversation 0 Commits 9 Files Changed 33 +702 -946
11 changed files with 702 additions and 946 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 7604594630 - Show all commits

39
source/coral/arena.zig
View File

@ -7,10 +7,10 @@ const list = @import("./list.zig");
const math = @import("./math.zig"); const math = @import("./math.zig");
pub const Stacking = struct { pub const Stacking = struct {
base_allocator: io.Allocator, page_allocator: io.Allocator,
min_page_size: usize, min_page_size: usize,
allocations: list.Stack(usize) = .{}, allocations: list.Stack(usize),
pages: list.Stack(Page) = .{}, pages: list.Stack(Page),
const Page = struct { const Page = struct {
buffer: []u8, buffer: []u8,
@ -49,11 +49,11 @@ pub const Stacking = struct {
} }
fn allocate_page(self: *Stacking, page_size: usize) io.AllocationError!*Page { fn allocate_page(self: *Stacking, page_size: usize) io.AllocationError!*Page {
var buffer = try io.allocate_many(self.base_allocator, page_size, u8); var buffer = try io.allocate_many(self.page_allocator, page_size, u8);
errdefer io.deallocate(self.base_allocator, buffer); errdefer io.deallocate(self.page_allocator, buffer);
try self.pages.push_one(self.base_allocator, .{ try self.pages.push_one(.{
.buffer = buffer, .buffer = buffer,
.used = 0, .used = 0,
}); });
@ -83,15 +83,6 @@ pub const Stacking = struct {
}.reallocate); }.reallocate);
} }
pub fn clear_allocations(self: *Stacking) void {
for (self.pages.values) |page| {
io.deallocate(self.base_allocator, page.buffer);
}
self.pages.deinit(self.base_allocator);
self.allocations.deinit(self.base_allocator);
}
fn current_page(self: Stacking) ?*Page { fn current_page(self: Stacking) ?*Page {
if (self.pages.values.len == 0) { if (self.pages.values.len == 0) {
return null; return null;
@ -99,4 +90,22 @@ pub const Stacking = struct {
return &self.pages.values[self.pages.values.len - 1]; return &self.pages.values[self.pages.values.len - 1];
} }
pub fn deinit(self: *Stacking) void {
for (self.pages.values) |page| {
io.deallocate(self.page_allocator, page.buffer);
}
self.pages.deinit();
self.allocations.deinit();
}
pub fn init(allocator: io.Allocator, min_page_size: usize) io.AllocationError!Stacking {
return Stacking{
.page_allocator = allocator,
.allocations = .{.allocator = allocator},
.pages = .{.allocator = allocator},
.min_page_size = min_page_size,
};
}
}; };

7
source/coral/io.zig
View File

@ -14,6 +14,11 @@ pub const AllocationOptions = struct {
pub const Allocator = Generator(?[]u8, AllocationOptions); pub const Allocator = Generator(?[]u8, AllocationOptions);
///
///
///
pub const Byte = u8;
/// ///
/// Function pointer coupled with an immutable state context for providing dynamic dispatch over a given `Input` and /// Function pointer coupled with an immutable state context for providing dynamic dispatch over a given `Input` and
/// `Output`. /// `Output`.
@ -134,7 +139,7 @@ pub const FixedBuffer = struct {
} }
}; };
pub const Writer = Generator(?usize, []const u8); pub const Writer = Generator(?usize, []const Byte);
pub fn allocate_many(allocator: Allocator, amount: usize, comptime Type: type) AllocationError![]Type { pub fn allocate_many(allocator: Allocator, amount: usize, comptime Type: type) AllocationError![]Type {
if (@sizeOf(Type) == 0) { if (@sizeOf(Type) == 0) {

89
source/coral/list.zig
View File

@ -9,6 +9,7 @@ const math = @import("./math.zig");
/// ///
pub fn Stack(comptime Value: type) type { pub fn Stack(comptime Value: type) type {
return struct { return struct {
allocator: io.Allocator,
capacity: usize = 0, capacity: usize = 0,
values: []Value = &.{}, values: []Value = &.{},
@ -34,12 +35,12 @@ pub fn Stack(comptime Value: type) type {
/// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation /// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation
/// strategy as the one originally used to allocate the current internal buffer. /// strategy as the one originally used to allocate the current internal buffer.
/// ///
pub fn deinit(self: *Self, allocator: io.Allocator) void { pub fn deinit(self: *Self) void {
if (self.capacity == 0) { if (self.capacity == 0) {
return; return;
} }
io.deallocate(allocator, self.values.ptr[0 .. self.capacity]); io.deallocate(self.allocator, self.values.ptr[0 .. self.capacity]);
self.values = &.{}; self.values = &.{};
self.capacity = 0; self.capacity = 0;
@ -69,21 +70,18 @@ pub fn Stack(comptime Value: type) type {
/// Growing ahead of multiple push operations is useful when the upper bound of pushes is well-understood, as it /// Growing ahead of multiple push operations is useful when the upper bound of pushes is well-understood, as it
/// can reduce the number of allocations required per push. /// can reduce the number of allocations required per push.
/// ///
/// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation pub fn grow(self: *Self, growth_amount: usize) io.AllocationError!void {
/// strategy as the one originally used to allocate the current internal buffer.
///
pub fn grow(self: *Self, allocator: io.Allocator, growth_amount: usize) io.AllocationError!void {
const grown_capacity = self.capacity + growth_amount; const grown_capacity = self.capacity + growth_amount;
const values = (try io.allocate_many(allocator, grown_capacity, Value))[0 .. self.values.len]; const values = (try io.allocate_many(self.allocator, grown_capacity, Value))[0 .. self.values.len];
errdefer io.deallocate(allocator, values); errdefer io.deallocate(self.allocator, values);
if (self.capacity != 0) { if (self.capacity != 0) {
for (0 .. self.values.len) |index| { for (0 .. self.values.len) |index| {
values[index] = self.values[index]; values[index] = self.values[index];
} }
io.deallocate(allocator, self.values.ptr[0 .. self.capacity]); io.deallocate(self.allocator, self.values.ptr[0 .. self.capacity]);
} }
self.values = values; self.values = values;
@ -113,14 +111,11 @@ pub fn Stack(comptime Value: type) type {
/// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the /// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the
/// internal buffer of `self` when necessary. /// internal buffer of `self` when necessary.
/// ///
/// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation pub fn push_all(self: *Self, values: []const Value) io.AllocationError!void {
/// strategy as the one originally used to allocate the current internal buffer.
///
pub fn push_all(self: *Self, allocator: io.Allocator, values: []const Value) io.AllocationError!void {
const new_length = self.values.len + values.len; const new_length = self.values.len + values.len;
if (new_length > self.capacity) { if (new_length > self.capacity) {
try self.grow(allocator, values.len + values.len); try self.grow(values.len + values.len);
} }
const offset_index = self.values.len; const offset_index = self.values.len;
@ -139,14 +134,11 @@ pub fn Stack(comptime Value: type) type {
/// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the /// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the
/// internal buffer of `self` when necessary. /// internal buffer of `self` when necessary.
/// ///
/// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation pub fn push_many(self: *Self, value: Value, amount: usize) io.AllocationError!void {
/// strategy as the one originally used to allocate the current internal buffer.
///
pub fn push_many(self: *Self, allocator: io.Allocator, value: Value, amount: usize) io.AllocationError!void {
const new_length = self.values.len + amount; const new_length = self.values.len + amount;
if (new_length >= self.capacity) { if (new_length >= self.capacity) {
try self.grow(allocator, amount + amount); try self.grow(amount + amount);
} }
const offset_index = self.values.len; const offset_index = self.values.len;
@ -165,12 +157,9 @@ pub fn Stack(comptime Value: type) type {
/// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the /// The function returns [io.AllocationError] if `allocator` could not commit the memory required to grow the
/// internal buffer of `self` when necessary. /// internal buffer of `self` when necessary.
/// ///
/// *Note* if the `capacity` field of `self` is a non-zero value, `allocator` must reference the same allocation pub fn push_one(self: *Self, value: Value) io.AllocationError!void {
/// strategy as the one originally used to allocate the current internal buffer.
///
pub fn push_one(self: *Self, allocator: io.Allocator, value: Value) io.AllocationError!void {
if (self.values.len == self.capacity) { if (self.values.len == self.capacity) {
try self.grow(allocator, math.max(1, self.capacity)); try self.grow(math.max(1, self.capacity));
} }
const offset_index = self.values.len; const offset_index = self.values.len;
@ -183,47 +172,19 @@ pub fn Stack(comptime Value: type) type {
} }
/// ///
/// Bridge context between a list type implement as part of the list module and an allocator, allowing the list resource
/// referenced by the [Writable] instance to be written to directly or virtually via the [io.Writer] interface.
/// ///
/// *Note* if the given list contains an existing allocation, the provided [io.Allocator] instance must reference the
/// same allocation strategy as the one originally used to allocate the list type memory.
/// ///
pub const Writable = struct { pub const ByteStack = Stack(io.Byte);
allocator: io.Allocator,
list: union (enum) { ///
stack: *ByteStack, /// Returns a [io.Writer] instance that binds a reference of `self` to the [write] operation.
}, ///
pub fn stack_as_writer(self: *ByteStack) io.Writer {
return io.Writer.bind(ByteStack, self, struct {
fn write(stack: *ByteStack, bytes: []const io.Byte) ?usize {
stack.push_all(bytes) catch return null;
/// return bytes.len;
/// Stack of bytes. }
/// }.write);
const ByteStack = Stack(u8); }
///
/// Returns a [io.Writer] instance that binds a reference of `self` to the [write] operation.
///
pub fn as_writer(self: *Writable) io.Writer {
return io.Writer.bind(Writable, self, struct {
fn write(writable: *Writable, bytes: []const u8) ?usize {
writable.write(bytes) catch return null;
return bytes.len;
}
}.write);
}
///
/// Attempts to call the appropriate multi-element writing function for the current list referenced by `self`,
/// passing `bytes` along.
///
/// The function returns [io.AllocationError] if `allocator` could not commit the memory by the list implementation
/// referenced by `self`. See the specific implementation details of the respective list type for more information.
///
pub fn write(self: *Writable, bytes: []const u8) io.AllocationError!void {
return switch (self.list) {
.stack => |stack| stack.push_all(self.allocator, bytes),
};
}
};

9
source/coral/slab.zig
View File

@ -19,6 +19,7 @@ const std = @import("std");
/// ///
pub fn Map(comptime index_int: std.builtin.Type.Int, comptime Value: type) type { pub fn Map(comptime index_int: std.builtin.Type.Int, comptime Value: type) type {
return struct { return struct {
allocator: io.Allocator,
free_index: Index = 0, free_index: Index = 0,
count: Index = 0, count: Index = 0,
table: []Entry = &.{}, table: []Entry = &.{},
@ -73,12 +74,12 @@ pub fn Map(comptime index_int: std.builtin.Type.Int, comptime Value: type) type
/// ///
/// Fetches the value referenced by `index` in `self`, returning it. /// Fetches the value referenced by `index` in `self`, returning it.
/// ///
pub fn fetch(self: *Self, index: Index) Value { pub fn fetch(self: *Self, index: Index) *Value {
const entry = &self.table[index]; const entry = &self.table[index];
debug.assert(entry.* == .value); debug.assert(entry.* == .value);
return entry.value; return &entry.value;
} }
/// ///
@ -125,9 +126,9 @@ pub fn Map(comptime index_int: std.builtin.Type.Int, comptime Value: type) type
/// *Note* if the `table` field of `self` is an allocated slice, `allocator` must reference the same allocation /// *Note* if the `table` field of `self` is an allocated slice, `allocator` must reference the same allocation
/// strategy as the one originally used to allocate the current table. /// strategy as the one originally used to allocate the current table.
/// ///
pub fn insert(self: *Self, allocator: io.Allocator, value: Value) io.AllocationError!Index { pub fn insert(self: *Self, value: Value) io.AllocationError!Index {
if (self.count == self.table.len) { if (self.count == self.table.len) {
try self.grow(allocator, math.max(1, self.count)); try self.grow(self.allocator, math.max(1, self.count));
} }
if (self.free_index == self.count) { if (self.free_index == self.count) {

33
source/coral/table.zig
View File

@ -22,6 +22,7 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
const growth_factor = 0.6; const growth_factor = 0.6;
return struct { return struct {
allocator: io.Allocator,
count: usize = 0, count: usize = 0,
table: []?Entry = &.{}, table: []?Entry = &.{},
@ -101,10 +102,7 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
/// The function returns [AllocationError] instead if `allocator` cannot commit the memory required to grow the /// The function returns [AllocationError] instead if `allocator` cannot commit the memory required to grow the
/// entry table of `self` when necessary. /// entry table of `self` when necessary.
/// ///
/// *Note* `allocator` must reference the same allocation strategy as the one originally used to initialize pub fn assign(self: *Self, key: Key, value: Value) io.AllocationError!?Entry {
/// `self`.
///
pub fn assign(self: *Self, allocator: io.Allocator, key: Key, value: Value) io.AllocationError!?Entry {
if (self.calculate_load_factor() >= load_max) { if (self.calculate_load_factor() >= load_max) {
const growth_size = @intToFloat(f64, math.max(1, self.table.len)) * growth_factor; const growth_size = @intToFloat(f64, math.max(1, self.table.len)) * growth_factor;
@ -112,7 +110,7 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
return error.OutOfMemory; return error.OutOfMemory;
} }
try self.rehash(allocator, @floatToInt(usize, growth_size)); try self.rehash(@floatToInt(usize, growth_size));
} }
debug.assert(self.table.len > self.count); debug.assert(self.table.len > self.count);
@ -174,15 +172,12 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
/// ///
/// To clear all items from the table while preserving the current capacity, see [clear] instead. /// To clear all items from the table while preserving the current capacity, see [clear] instead.
/// ///
/// *Note* `allocator` must reference the same allocation strategy as the one originally used to initialize pub fn deinit(self: *Self) void {
/// `self`.
///
pub fn deinit(self: *Self, allocator: io.Allocator) void {
if (self.table.len == 0) { if (self.table.len == 0) {
return; return;
} }
io.deallocate(allocator, self.table); io.deallocate(self.allocator, self.table);
self.table = &.{}; self.table = &.{};
self.count = 0; self.count = 0;
@ -195,15 +190,12 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
/// The function returns [AllocationError] instead if `allocator` cannot commit the memory required to grow the /// The function returns [AllocationError] instead if `allocator` cannot commit the memory required to grow the
/// entry table of `self` when necessary. /// entry table of `self` when necessary.
/// ///
/// *Note* `allocator` must reference the same allocation strategy as the one originally used to initialize pub fn insert(self: *Self, key: Key, value: Value) io.AllocationError!bool {
/// `self`.
///
pub fn insert(self: *Self, allocator: io.Allocator, key: Key, value: Value) io.AllocationError!bool {
if (self.calculate_load_factor() >= load_max) { if (self.calculate_load_factor() >= load_max) {
const growth_amount = @intToFloat(f64, self.table.len) * growth_factor; const growth_amount = @intToFloat(f64, self.table.len) * growth_factor;
const min_size = 1; const min_size = 1;
try self.rehash(allocator, self.table.len + math.max(min_size, @floatToInt(usize, growth_amount))); try self.rehash(self.table.len + math.max(min_size, @floatToInt(usize, growth_amount)));
} }
debug.assert(self.table.len > self.count); debug.assert(self.table.len > self.count);
@ -246,16 +238,13 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
/// greater than `requested_range`, returning [io.AllocationError] if `allocator` cannot commit the memory /// greater than `requested_range`, returning [io.AllocationError] if `allocator` cannot commit the memory
/// required for the table capacity size. /// required for the table capacity size.
/// ///
/// *Note* `allocator` must reference the same allocation strategy as the one originally used to initialize pub fn rehash(self: *Self, requested_range: usize) io.AllocationError!void {
/// `self`.
///
pub fn rehash(self: *Self, allocator: io.Allocator, requested_range: usize) io.AllocationError!void {
const old_table = self.table; const old_table = self.table;
self.table = try io.allocate_many(allocator, math.max(requested_range, self.count), ?Entry); self.table = try io.allocate_many(self.allocator, math.max(requested_range, self.count), ?Entry);
errdefer { errdefer {
io.deallocate(allocator, self.table); io.deallocate(self.allocator, self.table);
self.table = old_table; self.table = old_table;
} }
@ -272,7 +261,7 @@ pub fn Hashed(comptime Key: type, comptime Value: type, comptime keyer: Keyer(Ke
} }
} }
io.deallocate(allocator, old_table); io.deallocate(self.allocator, old_table);
} }
} }
}; };

540
source/ona/kym.zig
View File

@ -1,5 +1,541 @@
pub const Environment = @import("./kym/Environment.zig"); const Ast = @import("./kym/Ast.zig");
const coral = @import("coral"); const coral = @import("coral");
const types = @import("./kym/types.zig"); const file = @import("./file.zig");
const tokens = @import("./kym/tokens.zig");
///
///
///
pub const CallContext = struct {
env: *RuntimeEnv,
obj: Value,
args: []const Value = &.{},
///
///
///
pub fn arg_at(self: CallContext, index: Int) RuntimeError!Value {
if (!coral.math.is_clamped(index, 0, self.args.len - 1)) {
return self.env.check_fail("argument out of bounds");
}
return self.args[@intCast(usize, index)];
}
};
const Chunk = struct {
env: *RuntimeEnv,
opcodes: coral.list.Stack(Opcode),
///
///
///
const Opcode = union (enum) {
push_nil,
push_true,
push_false,
push_zero,
push_number: Float,
push_array: i32,
push_table: i32,
not,
neg,
add,
sub,
mul,
div,
eql,
cgt,
clt,
cge,
cle,
};
pub fn compile_ast(self: *Chunk, ast: Ast) void {
for (ast.list_statements()) |statement| {
switch (statement) {
.return_expression => |return_expression| {
try self.compile_expression(return_expression);
},
.return_nothing => {
try self.emit(.push_nil);
},
}
}
}
pub fn compile_expression(self: *Chunk, expression: Ast.Expression) void {
switch (expression) {
.nil_literal => try self.emit(.push_nil),
.true_literal => try self.emit(.push_true),
.false_literal => try self.emit(.push_false),
.integer_literal => |literal| try self.emit(if (literal == 0) .push_zero else .{.push_integer = literal}),
.float_literal => |literal| try self.emit(if (literal == 0) .push_zero else .{.push_float = literal}),
.string_literal => |literal| try self.emit(.{.push_object = try self.intern(literal)}),
.array_literal => |elements| {
if (elements.values.len > coral.math.max_int(@typeInfo(Int).Int)) {
return error.OutOfMemory;
}
for (elements.values) |element_expression| {
try self.compile_expression(element_expression);
}
try self.emit(.{.push_array = @intCast(Int, elements.values.len)});
},
.table_literal => |fields| {
if (fields.values.len > coral.math.max_int(@typeInfo(Int).Int)) {
return error.OutOfMemory;
}
for (fields.values) |field| {
try self.compile_expression(field.expression);
try self.emit(.{.push_object = try self.intern(field.identifier)});
}
try self.emit(.{.push_table = @intCast(Int, fields.values.len)});
},
.binary_operation => |operation| {
try self.compile_expression(operation.lhs_expression.*);
try self.compile_expression(operation.rhs_expression.*);
try self.emit(switch (operation.operator) {
.addition => .add,
.subtraction => .sub,
.multiplication => .mul,
.divsion => .div,
.greater_equals_comparison => .compare_eq,
.greater_than_comparison => .compare_gt,
.equals_comparison => .compare_ge,
.less_than_comparison => .compare_lt,
.less_equals_comparison => .compare_le,
});
},
.unary_operation => |operation| {
try self.compile_expression(operation.expression.*);
try self.emit(switch (operation.operator) {
.boolean_negation => .not,
.numeric_negation => .neg,
});
},
.grouped_expression => |grouped_expression| {
try self.compile_expression(grouped_expression.*);
}
}
}
pub fn deinit(self: *Chunk) void {
self.opcodes.deinit(self.env.allocator);
}
pub fn execute(self: *Chunk) RuntimeError!Value {
_ = self;
return Value.nil;
}
};
pub const Float = f64;
pub const Int = i32;
pub const Objectid = u32;
pub const RuntimeEnv = struct {
output: coral.io.Writer,
stack: coral.list.Stack(u64),
interned: coral.table.Hashed([]const u8, Objectid, coral.table.string_keyer),
objects: coral.slab.Map(@typeInfo(u32).Int, Object),
user_allocator: coral.io.Allocator,
pub const DataSource = struct {
name: []const u8,
data: []const u8,
};
pub const Limits = struct {
stack_max: u32,
calls_max: u32,
};
const Object = struct {
ref_count: usize,
state: struct {
info: ObjectInfo,
userdata: []u8,
fields: coral.table.Hashed(*Object, *Value, .{
.hasher = struct {
fn hash(object: *Object) coral.table.Hash {
coral.debug.assert(object.state.info.identity == null);
return coral.table.hash_string(object.state.userdata);
}
}.hash,
.comparer = struct {
fn compare(object_a: *Object, object_b: *Object) isize {
coral.debug.assert(object_a.state.info.identity == null);
coral.debug.assert(object_b.state.info.identity == null);
return coral.io.compare(object_a.state.userdata, object_b.state.userdata);
}
}.compare,
}),
},
};
pub const ObjectInfo = struct {
caller: *const fn (caller: Value, context: CallContext) RuntimeError!Value = default_call,
cleaner: *const fn (userdata: []u8) void = default_clean,
getter: *const fn (context: CallContext) RuntimeError!Value = default_get,
identity: ?*const anyopaque = null,
setter: *const fn (context: CallContext) RuntimeError!void = default_set,
fn default_call(_: Value, context: CallContext) RuntimeError!Value {
return context.env.fail(error.BadOperation, "attempt to call non-callable");
}
fn default_clean(_: []u8) void {
// Nothing to clean up by default.
}
fn default_get(context: CallContext) RuntimeError!Value {
return context.env.fail(error.BadOperation, "attempt to get non-indexable");
}
fn default_set(context: CallContext) RuntimeError!void {
return context.env.fail(error.BadOperation, "attempt to set non-indexable");
}
};
pub fn call(self: *RuntimeEnv, caller: Value, maybe_index: ?Value, args: []const Value) RuntimeError!RuntimeVar {
if (maybe_index) |index| {
const callable = try self.get(caller, index);
defer callable.deinit();
return switch (callable.value.unpack()) {
.objectid => |callable_id| .{
.env = self,
.value = try self.objects.fetch(callable_id).state.info.caller(.{
.env = self,
.callable = callable.value,
.obj = caller,
.args = args,
}),
},
else => self.fail(error.BadOperation, "attempt to call non-object type"),
};
}
return self.bind(try self.objects.fetch(try self.to_objectid(caller)).state.info.caller(.{
.env = self,
.obj = caller,
// .caller = .{.object = self.global_object},
.args = args,
}));
}
pub fn check(
self: *RuntimeEnv,
condition: bool,
runtime_error: RuntimeError,
failure_message: []const u8) RuntimeError!void {
if (condition) {
return;
}
return self.fail(runtime_error, failure_message);
}
pub fn deinit(self: *RuntimeEnv) void {
self.stack.deinit();
}
pub fn execute_data(self: *RuntimeEnv, allocator: coral.io.Allocator, source: DataSource) RuntimeError!RuntimeVar {
var ast = try Ast.init(allocator);
defer ast.deinit();
{
var tokenizer = tokens.Tokenizer{.source = source.data};
try ast.parse(&tokenizer);
}
var chunk = Chunk{
.env = self,
.opcodes = .{.allocator = allocator},
};
const typeid = "<chunk>";
const script = try self.new_object(allocator, coral.io.bytes_of(&chunk), .{
.identity = typeid,
.cleaner = struct {
fn clean(userdata: []const u8) void {
@ptrCast(*Chunk, @alignCast(@alignOf(Chunk), userdata)).deinit();
}
}.clean,
.caller = struct {
fn call(caller: Value, context: CallContext) RuntimeError!Value {
_ = caller;
return (context.env.native_cast(context.obj, typeid, Chunk) catch unreachable).execute();
}
}.call,
});
defer script.deinit();
return try self.call(script.value, null, &.{});
}
pub fn execute_file(
self: *RuntimeEnv,
allocator: coral.io.Allocator,
file_system: file.System,
file_path: file.Path) RuntimeError!RuntimeVar {
const readable_file = file_system.open_readable(file_path) catch return error.SystemFailure;
defer readable_file.close();
var file_data = coral.list.ByteStack{.allocator = allocator};
const file_size = (file_system.query_info(file_path) catch return error.SystemFailure).size;
try file_data.grow(file_size);
defer file_data.deinit();
{
var stream_buffer = [_]u8{0} ** 4096;
if ((coral.io.stream(coral.list.stack_as_writer(&file_data), readable_file.as_reader(), &stream_buffer) catch {
return error.SystemFailure;
}) != file_size) {
return error.SystemFailure;
}
}
return try self.execute_data(allocator, .{
.name = file_path.to_string() catch return error.SystemFailure,
.data = file_data.values,
});
}
pub fn fail(self: *RuntimeEnv, runtime_error: RuntimeError, failure_message: []const u8) RuntimeError {
// TODO: Call stack and line numbers.
coral.utf8.print_formatted(self.output, "{name}@({line}): {message}\n", .{
.name = ".ona",
.line = @as(u64, 0),
.message = failure_message,
}) catch return error.SystemFailure;
return runtime_error;
}
pub fn get(self: *RuntimeEnv, indexable: Value, index: Value) RuntimeError!RuntimeVar {
const indexable_object = self.objects.fetch(switch (indexable.unpack()) {
.objectid => |indexable_id| indexable_id,
else => return self.fail(error.BadOperation, "attempt to index non-indexable type"),
});
return .{
.env = self,
.value = try indexable_object.state.info.getter(.{
.env = self,
.obj = indexable,
.args = &.{index},
}),
};
}
pub fn init(allocator: coral.io.Allocator, output: coral.io.Writer, limits: Limits) RuntimeError!RuntimeEnv {
var env = RuntimeEnv{
.output = output,
.stack = .{.allocator = allocator},
.objects = .{.allocator = allocator},
.interned = .{.allocator = allocator},
.user_allocator = allocator,
};
try env.stack.grow(limits.stack_max * limits.calls_max);
errdefer env.stack.deinit();
return env;
}
pub fn intern(self: *RuntimeEnv, string: []const u8) RuntimeError!Value {
return Value.pack_objectid(self.interned.lookup(string) orelse {
const interned_value = (try self.new_string(string)).value;
switch (interned_value.unpack()) {
.objectid => |id| coral.debug.assert(try self.interned.insert(string, id)),
else => unreachable,
}
return interned_value;
});
}
pub fn native_cast(self: *RuntimeEnv, castable: Value, id: *const anyopaque, comptime Type: type) RuntimeError!*Type {
const object = self.objects.fetch(castable.to_objectid() orelse {
return self.fail(error.BadOperation, "attempt to cast non-castable type");
});
const is_expected_type = (object.state.info.identity == id) and (object.state.userdata.len == @sizeOf(Type));
try self.check(is_expected_type, "invalid object cast: native type");
return @ptrCast(*Type, @alignCast(@alignOf(Type), object.state.userdata));
}
pub fn new_object(self: *RuntimeEnv, allocator: coral.io.Allocator, userdata: []const u8, info: ObjectInfo) RuntimeError!RuntimeVar {
const allocation = try coral.io.allocate_many(allocator, userdata.len, u8);
errdefer coral.io.deallocate(allocator, allocation);
coral.io.copy(allocation, userdata);
const objectid = try self.objects.insert(.{
.ref_count = 1,
.state = .{
.info = info,
.userdata = allocation,
.fields = .{.allocator = allocator},
},
});
return .{
.env = self,
.value = .{.data = @as(usize, 0x7FF8000000000002) | (@as(usize, objectid) << 32)},
};
}
pub fn new_string(self: *RuntimeEnv, data: []const u8) RuntimeError!RuntimeVar {
return try self.new_object(data, .{
.getter = struct {
fn get_byte(context: CallContext) RuntimeError!*Value {
const string = context.env.string_cast(context.obj) catch unreachable;
const index = try context.env.to_int(try context.arg_at(0));
try context.env.check(coral.math.is_clamped(index, 0, string.len), "index out of string bounds");
return context.env.new_int(string[@intCast(usize, index)]);
}
}.get_byte,
});
}
};
pub const RuntimeError = coral.io.AllocationError || Ast.ParseError || error {
BadOperation,
BadArgument,
SystemFailure,
};
pub const RuntimeVar = struct {
value: Value,
env: *RuntimeEnv,
pub fn deinit(self: RuntimeVar) void {
switch (self.value.unpack()) {
.objectid => |id| {
const object = self.env.objects.fetch(id);
coral.debug.assert(object.ref_count != 0);
object.ref_count -= 1;
if (object.ref_count == 0) {
object.state.info.cleaner(object.state.userdata);
// TODO: Free individual key-value pairs of fields
object.state.fields.deinit();
coral.io.deallocate(self.env.user_allocator, object.state.userdata);
self.env.objects.remove(id);
}
},
else => {},
}
}
};
pub const Value = struct {
data: u64,
pub const Unpacked = union (enum) {
nil,
false,
true,
number: Float,
objectid: Objectid,
};
fn pack_number(float: Float) Value {
return @bitCast(Value, float);
}
fn pack_objectid(id: Objectid) Value {
return signature.objectid | id;
}
pub const @"false" = @as(Value, nan | 0x0001000000000000);
const mask = .{
.sign = @as(u64, 0x8000000000000000),
.exponent = @as(u64, 0x7ff0000000000000),
.quiet = @as(u64, 0x0008000000000000),
.type = @as(u64, 0x0007000000000000),
.signature = @as(u64, 0xffff000000000000),
.object = @as(u64, 0x00000000ffffffff),
};
pub const nan = @as(Value, mask.exponent | mask.quiet);
pub const nil = @as(Value, nan | 0x0003000000000000);
const signature = .{
};
pub const @"true" = @as(Value, nan | 0x0002000000000000);
pub fn unpack(self: Value) Unpacked {
if ((~self.data & mask.exponent) != 0) {
return .{.number = @bitCast(Float, self.data)};
}
return switch ((self.data & mask.signature) != 0) {
.signature_nan => .{.number = @bitCast(Float, self.data)},
.signature_false => .false,
.signature_true => .true,
.signature_object => @intCast(Objectid, self.data & mask.object),
else => return .nil,
};
}
};

80
source/ona/kym/Ast.zig
View File

@ -2,8 +2,6 @@ const coral = @import("coral");
const tokens = @import("./tokens.zig"); const tokens = @import("./tokens.zig");
const types = @import("./types.zig");
allocator: coral.io.Allocator, allocator: coral.io.Allocator,
arena: coral.arena.Stacking, arena: coral.arena.Stacking,
statements: StatementList, statements: StatementList,
@ -39,8 +37,8 @@ pub const Expression = union (enum) {
nil_literal, nil_literal,
true_literal, true_literal,
false_literal, false_literal,
integer_literal: types.Integer, integer_literal: []const u8,
float_literal: types.Float, float_literal: []const u8,
string_literal: []const u8, string_literal: []const u8,
array_literal: coral.list.Stack(Expression), array_literal: coral.list.Stack(Expression),
@ -63,7 +61,15 @@ pub const Expression = union (enum) {
}, },
}; };
const ExpressionParser = fn (self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expression; const ExpressionParser = fn (self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression;
///
///
///
pub const ParseError = error {
OutOfMemory,
BadSyntax,
};
const Self = @This(); const Self = @This();
@ -81,7 +87,7 @@ const UnaryOperator = enum {
fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime operators: []const BinaryOperator) ExpressionParser { fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime operators: []const BinaryOperator) ExpressionParser {
return struct { return struct {
fn parse(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expression { fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression {
var expression = try parse_next(self, tokenizer); var expression = try parse_next(self, tokenizer);
{ {
@ -111,7 +117,7 @@ fn binary_operation_parser(comptime parse_next: ExpressionParser, comptime opera
}.parse; }.parse;
} }
fn check_syntax(self: *Self, condition: bool, error_message: []const u8) types.ParseError!void { fn check_syntax(self: *Self, condition: bool, error_message: []const u8) ParseError!void {
if (condition) { if (condition) {
return; return;
} }
@ -120,11 +126,11 @@ fn check_syntax(self: *Self, condition: bool, error_message: []const u8) types.P
} }
pub fn deinit(self: *Self) void { pub fn deinit(self: *Self) void {
self.arena.clear_allocations(); self.arena.deinit();
self.statements.deinit(self.allocator); self.statements.deinit();
} }
fn fail_syntax(self: *Self, error_message: []const u8) types.ParseError { fn fail_syntax(self: *Self, error_message: []const u8) ParseError {
self.error_message = error_message; self.error_message = error_message;
return error.BadSyntax; return error.BadSyntax;
@ -132,13 +138,9 @@ fn fail_syntax(self: *Self, error_message: []const u8) types.ParseError {
pub fn init(allocator: coral.io.Allocator) coral.io.AllocationError!Self { pub fn init(allocator: coral.io.Allocator) coral.io.AllocationError!Self {
return Self{ return Self{
.arena = .{ .arena = try coral.arena.Stacking.init(allocator, 4096),
.base_allocator = allocator,
.min_page_size = 4096,
},
.allocator = allocator, .allocator = allocator,
.statements = .{}, .statements = .{.allocator = allocator},
.error_message = "", .error_message = "",
}; };
} }
@ -147,7 +149,7 @@ pub fn list_statements(self: Self) []const Statement {
return self.statements.values; return self.statements.values;
} }
pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!void { pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!void {
self.reset(); self.reset();
errdefer self.reset(); errdefer self.reset();
@ -159,7 +161,7 @@ pub fn parse(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!void {
.keyword_return => { .keyword_return => {
try self.check_syntax(has_not_returned_yet, "cannot return more than once per function scope"); try self.check_syntax(has_not_returned_yet, "cannot return more than once per function scope");
try self.statements.push_one(self.allocator, get_statement: { try self.statements.push_one(get_statement: {
if (tokenizer.step(.{.include_newlines = true})) { if (tokenizer.step(.{.include_newlines = true})) {
if (tokenizer.current_token != .newline) { if (tokenizer.current_token != .newline) {
break: get_statement .{.return_expression = try self.parse_expression(tokenizer)}; break: get_statement .{.return_expression = try self.parse_expression(tokenizer)};
@ -199,7 +201,7 @@ const parse_expression = binary_operation_parser(parse_equality, &.{
.subtraction, .subtraction,
}); });
fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expression { fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) ParseError!Expression {
switch (tokenizer.current_token) { switch (tokenizer.current_token) {
.symbol_paren_left => { .symbol_paren_left => {
try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "expected an expression after `(`"); try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "expected an expression after `(`");
@ -216,26 +218,13 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expr
.integer => |value| { .integer => |value| {
_ = tokenizer.step(.{.include_newlines = false}); _ = tokenizer.step(.{.include_newlines = false});
return Expression{ return Expression{.integer_literal = value};
.integer_literal = coral.utf8.parse_decimal(types.Integer, value, .{}) catch |parse_error| {
return self.fail_syntax(switch (parse_error) {
error.BadSyntax => "invalid integer literal",
error.IntOverflow => "integer literal is too big",
});
},
};
}, },
.real => |value| { .real => |value| {
_ = tokenizer.step(.{.include_newlines = false}); _ = tokenizer.step(.{.include_newlines = false});
return Expression{ return Expression{.float_literal = value};
.float_literal = coral.utf8.parse_decimal(types.Float, value, .{}) catch |parse_error| {
return self.fail_syntax(switch (parse_error) {
error.BadSyntax => "invalid float literal",
});
},
};
}, },
.string => |value| { .string => |value| {
@ -247,14 +236,17 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expr
.symbol_bracket_left => { .symbol_bracket_left => {
try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end of array literal"); try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end of array literal");
var expression = Expression{.array_literal = .{}}; var expression = Expression{
.array_literal = .{
.allocator = self.arena.as_allocator(),
},
};
coral.debug.assert(expression == .array_literal); coral.debug.assert(expression == .array_literal);
const allocator = self.arena.as_allocator();
const array_average_maximum = 32; const array_average_maximum = 32;
try expression.array_literal.grow(allocator, array_average_maximum); try expression.array_literal.grow(array_average_maximum);
while (true) { while (true) {
switch (tokenizer.current_token) { switch (tokenizer.current_token) {
@ -269,7 +261,7 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expr
tokenizer.step(.{.include_newlines = false}), tokenizer.step(.{.include_newlines = false}),
"expected `]` or expression after `[`"); "expected `]` or expression after `[`");
try expression.array_literal.push_one(allocator, try self.parse_expression(tokenizer)); try expression.array_literal.push_one(try self.parse_expression(tokenizer));
}, },
} }
} }
@ -278,12 +270,14 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expr
.symbol_brace_left => { .symbol_brace_left => {
try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end of table literal"); try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end of table literal");
var expression = Expression{.table_literal = .{}}; var expression = Expression{
.table_literal = .{
.allocator = self.arena.as_allocator(),
},
};
coral.debug.assert(expression == .table_literal); coral.debug.assert(expression == .table_literal);
const allocator = self.arena.as_allocator();
while (true) { while (true) {
switch (tokenizer.current_token) { switch (tokenizer.current_token) {
.symbol_brace_right => { .symbol_brace_right => {
@ -299,7 +293,7 @@ fn parse_factor(self: *Self, tokenizer: *tokens.Tokenizer) types.ParseError!Expr
try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end after `=`"); try self.check_syntax(tokenizer.step(.{.include_newlines = false}), "unexpected end after `=`");
try expression.table_literal.push_one(allocator, .{ try expression.table_literal.push_one(.{
.identifier = identifier, .identifier = identifier,
.expression = try self.parse_expression(tokenizer), .expression = try self.parse_expression(tokenizer),
}); });
@ -365,5 +359,5 @@ const parse_term = binary_operation_parser(parse_factor, &.{
pub fn reset(self: *Self) void { pub fn reset(self: *Self) void {
self.statements.clear(); self.statements.clear();
self.arena.clear_allocations(); self.arena.deinit();
} }

247
source/ona/kym/Chunk.zig
View File

@ -1,247 +0,0 @@
const Ast = @import("./Ast.zig");
const Environment = @import("./Environment.zig");
const coral = @import("coral");
const types = @import("./types.zig");
const tokens = @import("./tokens.zig");
env: *Environment,
message_name_len: usize,
message_data: Buffer,
bytecode_buffer: Buffer,
const Buffer = coral.list.Stack(u8);
const Opcode = enum (u8) {
ret,
push_nil,
push_true,
push_false,
push_zero,
push_integer,
push_float,
push_object,
push_array,
push_table,
not,
neg,
add,
sub,
mul,
div,
compare_eq,
compare_gt,
compare_lt,
compare_ge,
compare_le,
};
const Self = @This();
fn clear_error_details(self: *Self) void {
coral.debug.assert(self.message_data.values.len >= self.message_name_len);
coral.debug.assert(self.message_data.drop(self.message_data.values.len - self.message_name_len));
}
pub fn compile(self: *Self, data: []const u8) types.RuntimeError!void {
var ast = try Ast.init(self.env.allocator);
defer ast.deinit();
{
var tokenizer = tokens.Tokenizer{.source = data};
ast.parse(&tokenizer) catch |init_error| {
if (init_error == error.BadSyntax) {
self.clear_error_details();
var writable_data = coral.list.Writable{
.allocator = self.env.allocator,
.list = .{.stack = &self.message_data},
};
coral.utf8.print_formatted(writable_data.as_writer(), "@({line}): {name}", .{
.line = tokenizer.lines_stepped,
.name = ast.error_message,
}) catch return error.OutOfMemory;
}
return init_error;
};
}
for (ast.list_statements()) |statement| {
switch (statement) {
.return_expression => |return_expression| {
try self.compile_expression(return_expression);
try self.emit_opcode(.ret);
},
.return_nothing => {
try self.emit_opcode(.push_nil);
try self.emit_opcode(.ret);
},
}
}
}
pub fn compile_expression(self: *Self, expression: Ast.Expression) types.RuntimeError!void {
switch (expression) {
.nil_literal => try self.emit_opcode(.push_nil),
.true_literal => try self.emit_opcode(.push_true),
.false_literal => try self.emit_opcode(.push_false),
.integer_literal => |literal| {
if (literal == 0) {
try self.emit_opcode(.push_zero);
} else {
try self.emit_opcode(.push_integer);
try self.emit_float(0);
}
},
.float_literal => |literal| {
if (literal == 0) {
try self.emit_opcode(.push_zero);
} else {
try self.emit_opcode(.push_float);
try self.emit_float(literal);
}
},
.string_literal => |literal| {
try self.emit_opcode(.push_object);
try self.emit_object(try self.intern(literal));
},
.array_literal => |elements| {
if (elements.values.len > coral.math.max_int(@typeInfo(types.Integer).Int)) {
return error.OutOfMemory;
}
for (elements.values) |element_expression| {
try self.compile_expression(element_expression);
}
try self.emit_opcode(.push_array);
try self.emit_integer(@intCast(types.Integer, elements.values.len));
},
.table_literal => |fields| {
if (fields.values.len > coral.math.max_int(@typeInfo(types.Integer).Int)) {
return error.OutOfMemory;
}
for (fields.values) |field| {
try self.compile_expression(field.expression);
try self.emit_opcode(.push_object);
try self.emit_object(try self.intern(field.identifier));
}
try self.emit_opcode(.push_table);
try self.emit_integer(@intCast(types.Integer, fields.values.len));
},
.binary_operation => |operation| {
try self.compile_expression(operation.lhs_expression.*);
try self.compile_expression(operation.rhs_expression.*);
try self.emit_opcode(switch (operation.operator) {
.addition => .add,
.subtraction => .sub,
.multiplication => .mul,
.divsion => .div,
.greater_equals_comparison => .compare_eq,
.greater_than_comparison => .compare_gt,
.equals_comparison => .compare_ge,
.less_than_comparison => .compare_lt,
.less_equals_comparison => .compare_le,
});
},
.unary_operation => |operation| {
try self.compile_expression(operation.expression.*);
try self.emit_opcode(switch (operation.operator) {
.boolean_negation => .not,
.numeric_negation => .neg,
});
},
.grouped_expression => |grouped_expression| {
try self.compile_expression(grouped_expression.*);
}
}
}
pub fn deinit(self: *Self) void {
self.bytecode_buffer.deinit(self.env.allocator);
self.message_data.deinit(self.env.allocator);
self.message_name_len = 0;
}
pub fn emit_float(self: *Self, float: types.Float) coral.io.AllocationError!void {
try self.bytecode_buffer.push_all(self.env.allocator, coral.io.bytes_of(&float));
}
pub fn emit_integer(self: *Self, integer: types.Integer) coral.io.AllocationError!void {
try self.bytecode_buffer.push_all(self.env.allocator, coral.io.bytes_of(&integer));
}
pub fn emit_object(self: *Self, object: types.Object) coral.io.AllocationError!void {
try self.bytecode_buffer.push_all(self.env.allocator, coral.io.bytes_of(&object));
}
pub fn emit_opcode(self: *Self, opcode: Opcode) coral.io.AllocationError!void {
try self.bytecode_buffer.push_one(self.env.allocator, @enumToInt(opcode));
}
pub fn error_details(self: Self) []const u8 {
coral.debug.assert(self.message_data.values.len >= self.message_name_len);
return self.message_data.values;
}
pub fn execute(self: *Self) types.RuntimeError!types.Val {
_ = self;
// TODO: Implement.
return .nil;
}
pub fn init(env: *Environment, chunk_name: []const u8) coral.io.AllocationError!Self {
var message_data = Buffer{};
try message_data.push_all(env.allocator, chunk_name);
errdefer message_data.deinit(env.allocator);
return Self{
.env = env,
.message_data = message_data,
.bytecode_buffer = .{},
.message_name_len = chunk_name.len,
};
}
pub fn intern(self: *Self, string: []const u8) coral.io.AllocationError!types.Object {
const interned_string = try self.env.intern(string);
coral.debug.assert(interned_string == .object);
return interned_string.object;
}
pub fn name(self: Self) []const u8 {
coral.debug.assert(self.message_data.values.len >= self.message_name_len);
return self.message_data.values[0 .. self.message_name_len];
}

466
source/ona/kym/Environment.zig
View File

@ -1,466 +0,0 @@
const Chunk = @import("./Chunk.zig");
const coral = @import("coral");
const file = @import("../file.zig");
const types = @import("./types.zig");
const tokens = @import("./tokens.zig");
allocator: coral.io.Allocator,
heap: ObjectSlab,
global_object: types.Object,
interned: InternTable,
reporter: Reporter,
values: ValueStack,
calls: CallStack,
const CallStack = coral.list.Stack(struct {
ip: usize,
slots: []types.Val,
});
pub const DataSource = struct {
name: []const u8,
data: []const u8,
};
pub const ExecuteFileError = file.System.OpenError || coral.io.StreamError || file.ReadError || types.RuntimeError;
pub const InitOptions = struct {
values_max: u32,
calls_max: u32,
reporter: Reporter,
};
const InternTable = coral.table.Hashed([]const u8, types.Object, coral.table.string_keyer);
const Object = struct {
ref_count: usize,
state: struct {
info: ObjectInfo,
userdata: []u8,
fields: Fields,
},
const Fields = coral.table.Hashed(*Object, types.Val, .{
.hasher = struct {
fn hash(object: *Object) coral.table.Hash {
coral.debug.assert(object.state.info.identity == null);
return coral.table.hash_string(object.state.userdata);
}
}.hash,
.comparer = struct {
fn compare(object_a: *Object, object_b: *Object) isize {
coral.debug.assert(object_a.state.info.identity == null);
coral.debug.assert(object_b.state.info.identity == null);
return coral.io.compare(object_a.state.userdata, object_b.state.userdata);
}
}.compare,
});
pub fn acquire(self: *Object) void {
coral.debug.assert(self.ref_count != 0);
self.ref_count += 1;
}
};
pub const ObjectInfo = struct {
caller: *const Caller = default_call,
deinitializer: *const Deinitializer = default_deinitialize,
getter: *const Getter = default_get,
identity: ?*const anyopaque = null,
setter: *const Setter = default_set,
pub const CallContext = struct {
env: *Self,
caller: types.Ref,
callable: types.Ref,
args: []const types.Ref,
};
pub const Caller = fn (context: CallContext) types.RuntimeError!types.Val;
pub const DeinitializeContext = struct {
env: *Self,
obj: types.Ref,
};
pub const Deinitializer = fn (context: DeinitializeContext) void;
pub const GetContext = struct {
env: *Self,
indexable: types.Ref,
index: types.Ref,
};
pub const Getter = fn (context: GetContext) types.RuntimeError!types.Val;
pub const SetContext = struct {
env: *Self,
indexable: types.Ref,
index: types.Ref,
value: types.Ref,
};
pub const Setter = fn (context: SetContext) types.RuntimeError!void;
fn default_call(context: CallContext) types.RuntimeError!types.Val {
return context.env.fail("attempt to call non-callable");
}
fn default_deinitialize(_: DeinitializeContext) void {
// Nothing to deinitialize by default.
}
fn default_get(context: GetContext) types.RuntimeError!types.Val {
return context.env.get_field(context.indexable, context.index);
}
fn default_set(context: SetContext) types.RuntimeError!void {
return context.env.fail("attempt to set non-indexable");
}
};
const ObjectSlab = coral.slab.Map(@typeInfo(u32).Int, Object);
pub const Reporter = coral.io.Functor(void, []const u8);
const Self = @This();
const ValueStack = coral.list.Stack(types.Ref);
pub fn call(self: *Self, caller: types.Ref, maybe_index: ?types.Ref, args: []const types.Ref) types.RuntimeError!types.Val {
if (maybe_index) |index| {
try self.check(caller == .object, "invalid type conversion: object");
const callable = try self.get_object(caller, index);
defer self.discard(callable);
try self.check(callable == .object, "invalid type conversion: object");
return self.heap.fetch(callable.object).state.info.caller(.{
.env = self,
.callable = callable.as_ref(),
.caller = caller,
.args = args,
});
}
return self.heap.fetch(caller.object).state.info.caller(.{
.env = self,
.callable = caller,
.caller = .{.object = self.global_object},
.args = args,
});
}
pub fn check(self: *Self, condition: bool, failure_message: []const u8) !void {
if (condition) {
return;
}
return self.fail(failure_message);
}
pub fn deinit(self: *Self) void {
self.object_release(self.global_object);
{
var interned_iterable = InternTable.Iterable{.hashed_map = &self.interned};
while (interned_iterable.next()) |entry| {
self.object_release(entry.value);
}
}
self.interned.deinit(self.allocator);
self.values.deinit(self.allocator);
self.calls.deinit(self.allocator);
coral.debug.assert(self.heap.is_empty());
self.heap.deinit(self.allocator);
}
pub fn discard(self: *Self, val: types.Val) void {
switch (val) {
.object => |object| self.object_release(object),
else => {},
}
}
pub fn execute_data(self: *Self, source: DataSource) types.RuntimeError!types.Val {
const typeid = "<chunk>";
const Behaviors = struct {
fn call(context: ObjectInfo.CallContext) types.RuntimeError!types.Val {
return (context.env.native_cast(context.callable, typeid, Chunk) catch unreachable).execute();
}
fn deinitialize(context: ObjectInfo.DeinitializeContext) void {
(context.env.native_cast(context.obj, typeid, Chunk) catch unreachable).deinit();
}
};
var compiled_chunk = init_compiled_chunk: {
var chunk = try Chunk.init(self, source.name);
errdefer chunk.deinit();
chunk.compile(source.data) catch |compile_error| {
self.reporter.invoke(chunk.error_details());
return compile_error;
};
break: init_compiled_chunk chunk;
};
const script = try self.new_object(coral.io.bytes_of(&compiled_chunk), .{
.identity = typeid,
.deinitializer = Behaviors.deinitialize,
.caller = Behaviors.call,
});
defer self.discard(script);
return try self.call(script.as_ref(), null, &.{});
}
pub fn execute_file(self: *Self, fs: file.System, file_path: file.Path) ExecuteFileError!types.Val {
const readable_file = try fs.open_readable(file_path);
defer readable_file.close();
var file_data = coral.list.Stack(u8){};
const file_size = (try fs.query_info(file_path)).size;
try file_data.grow(self.allocator, file_size);
defer file_data.deinit(self.allocator);
{
var writable_data = coral.list.Writable{
.allocator = self.allocator,
.list = .{.stack = &file_data},
};
var stream_buffer = [_]u8{0} ** 4096;
if ((try coral.io.stream(writable_data.as_writer(), readable_file.as_reader(), &stream_buffer)) != file_size) {
return error.ReadFailure;
}
}
return try self.execute_data(.{
.name = try file_path.to_string(),
.data = file_data.values,
});
}
pub fn fail(self: *Self, failure_message: []const u8) types.CheckError {
self.reporter.invoke(failure_message);
return error.CheckFailed;
}
pub fn get_field(self: *Self, indexable: types.Ref, field: types.Ref) !types.Val {
try self.check(indexable == .object, "invalid type conversion: object");
try self.check(field == .object, "invalid type conversion: object");
const value = get_value: {
var field_data = self.heap.fetch(field.object);
break: get_value self.heap.fetch(indexable.object).state.fields.lookup(&field_data) orelse {
return .nil;
};
};
if (value == .object) {
var value_data = self.heap.fetch(value.object);
value_data.acquire();
self.heap.assign(value.object, value_data);
}
return value;
}
pub fn get_object(self: *Self, indexable: types.Ref, index: types.Ref) types.RuntimeError!types.Val {
try self.check(indexable == .object, "invalid type conversion: object");
return self.heap.fetch(indexable.object).state.info.getter(.{
.env = self,
.indexable = indexable,
.index = index,
});
}
pub fn init(allocator: coral.io.Allocator, options: InitOptions) !Self {
var env = Self{
.global_object = 0,
.allocator = allocator,
.reporter = options.reporter,
.interned = .{},
.values = .{},
.calls = .{},
.heap = .{},
};
errdefer {
env.values.deinit(allocator);
env.calls.deinit(allocator);
}
try env.values.grow(allocator, options.values_max * options.calls_max);
try env.calls.grow(allocator, options.calls_max);
{
const globals = try env.new_object(&.{}, .{
.identity = "KYM GLOBAL OBJECT OC DO NOT STEAL",
});
coral.debug.assert(globals == .object);
env.global_object = globals.object;
}
return env;
}
pub fn intern(self: *Self, string: []const u8) coral.io.AllocationError!types.Ref {
return .{.object = self.interned.lookup(string) orelse {
const reference = try self.new_string(string);
coral.debug.assert(reference == .object);
coral.debug.assert(try self.interned.insert(self.allocator, string, reference.object));
return .{.object = reference.object};
}};
}
pub fn native_cast(self: *Self, castable: types.Ref, id: *const anyopaque, comptime Type: type) types.RuntimeError!*Type {
try self.check(castable == .object, "invalid type conversion: object");
const object = self.heap.fetch(castable.object);
const is_expected_type = (object.state.info.identity == id) and (object.state.userdata.len == @sizeOf(Type));
try self.check(is_expected_type, "invalid object cast: native type");
return @ptrCast(*Type, @alignCast(@alignOf(Type), object.state.userdata));
}
pub fn new_array(self: *Self) coral.io.AllocationError!types.Val {
return try self.new_object(.{
});
}
pub fn new_object(self: *Self, userdata: []const u8, info: ObjectInfo) coral.io.AllocationError!types.Val {
const allocation = try coral.io.allocate_many(self.allocator, userdata.len, u8);
errdefer coral.io.deallocate(self.allocator, allocation);
coral.io.copy(allocation, userdata);
return .{.object = try self.heap.insert(self.allocator, .{
.ref_count = 1,
.state = .{
.info = info,
.userdata = allocation,
.fields = .{},
},
})};
}
pub fn new_string(self: *Self, data: []const u8) coral.io.AllocationError!types.Val {
const Behavior = struct {
fn get_byte(context: ObjectInfo.GetContext) types.RuntimeError!types.Val {
switch (context.index) {
.integer => |integer| {
const string = context.env.string_cast(context.indexable) catch unreachable;
try context.env.check(coral.math.is_clamped(integer, 0, string.len), "index out of string bounds");
return types.Val{.integer = string[@intCast(usize, integer)]};
},
else => return context.env.fail("attempt to index string with non-integer value"),
}
}
};
return try self.new_object(data, .{
.getter = Behavior.get_byte,
});
}
pub fn object_release(self: *Self, object: types.Object) void {
var data = self.heap.fetch(object);
coral.debug.assert(data.ref_count != 0);
data.ref_count -= 1;
if (data.ref_count == 0) {
data.state.info.deinitializer(.{
.env = self,
.obj = .{.object = object},
});
// TODO: Free individual key-value pairs of fields
data.state.fields.deinit(self.allocator);
coral.io.deallocate(self.allocator, data.state.userdata);
self.heap.remove(object);
} else {
self.heap.assign(object, data);
}
}
pub fn set_global(self: *Self, global_name: []const u8, value: types.Ref) coral.io.AllocationError!void {
try self.globals.assign(self.allocator, global_name, value);
}
pub fn set_object(self: *Self, obj: *Object, index: types.Ref, value: types.Ref) types.RuntimeError!void {
return obj.behavior.setter(.{
.env = self,
.obj = obj,
.index = index,
.value = value,
});
}
pub fn string_cast(self: *Self, value: types.Ref) ![]const u8 {
try self.check(value == .object, "invalid type conversion: object");
const object = self.heap.fetch(value.object);
try self.check(object.state.info.identity == null, "invalid object cast: string");
return object.state.userdata;
}
pub fn to_integer(self: *Self, value: types.Ref) !types.Integer {
const fail_message = "invalid type conversion: integer";
switch (value) {
.float => |float| {
const int = @typeInfo(types.Integer).Int;
if (coral.math.is_clamped(float, coral.math.min_int(int), coral.math.max_int(int))) {
return @floatToInt(types.Integer, float);
}
},
.integer => |integer| return integer,
else => {},
}
return self.fail(fail_message);
}

56
source/ona/kym/types.zig
View File

@ -1,56 +0,0 @@
const coral = @import("coral");
pub const CheckError = error {
CheckFailed
};
pub const Float = f32;
pub const Integer = i32;
pub const Object = u32;
pub const Primitive = enum {
nil,
false,
true,
float,
integer,
object,
};
pub const Ref = union (Primitive) {
nil,
false,
true,
float: Float,
integer: Integer,
object: Object,
};
pub const ParseError = error {
OutOfMemory,
BadSyntax,
};
pub const RuntimeError = CheckError || ParseError;
pub const Val = union (Primitive) {
nil,
false,
true,
float: Float,
integer: Integer,
object: Object,
pub fn as_ref(self: *const Val) Ref {
return switch (self.*) {
.nil => .nil,
.false => .false,
.true => .true,
.float => .{.float = self.float},
.integer => .{.integer = self.integer},
.object => .{.object = self.object},
};
}
};

82
source/ona/ona.zig
View File

@ -17,69 +17,99 @@ const AppManifest = struct {
width: u16 = 640, width: u16 = 640,
height: u16 = 480, height: u16 = 480,
pub fn load_script(self: *AppManifest, env: *kym.Environment, fs: file.System, file_path: []const u8) !void { pub fn load_script(self: *AppManifest, env: *kym.RuntimeEnv, fs: file.System, file_path: []const u8) !void {
const manifest = try env.execute_file(fs, file.Path.from(&.{file_path})); var manifest = try env.execute_file(heap.allocator, fs, file.Path.from(&.{file_path}));
defer env.discard(manifest); defer manifest.deinit();
const manifest_ref = manifest.as_ref();
{ {
const title = try env.get_field(manifest_ref, try env.intern("title")); var title = try env.get(manifest.value, try env.intern("title"));
defer env.discard(title); defer title.deinit();
const title_string = try env.string_cast(title.as_ref()); const title_string = try env.string_cast(title.value);
try env.check(title_string.len <= self.title.len, "`title` cannot exceed 255 bytes in length"); try env.check(title_string.len <= self.title.len, "`title` cannot exceed 255 bytes in length");
coral.io.copy(&self.title, title_string); coral.io.copy(&self.title, title_string);
} }
const u16_int = @typeInfo(u16).Int; const u16_max = coral.math.max_int(@typeInfo(u16).Int);
{ {
const width = try env.get_field(manifest_ref, try env.intern("width")); const width = try env.get(manifest.value, try env.intern("width"));
errdefer env.discard(width); errdefer width.deinit();
self.width = try coral.math.checked_cast(u16_int, try env.to_integer(width.as_ref())); if (width.value.as_number()) |value| {
if (value < u16_max) {
self.width = @floatToInt(u16, value);
}
}
} }
{ {
const height = try env.get_field(manifest_ref, try env.intern("height")); const height = try env.get(manifest.value, try env.intern("height"));
errdefer env.discard(height); errdefer height.deinit();
self.width = try coral.math.checked_cast(u16_int, try env.to_integer(height.as_ref())); if (height.value.as_number()) |value| {
if (value < u16_max) {
self.height = @floatToInt(u16, value);
}
}
} }
} }
}; };
fn stack_as_log_writer(self: *coral.list.ByteStack) coral.io.Writer {
return coral.io.Writer.bind(coral.list.ByteStack, self, struct {
fn write(stack: *coral.list.ByteStack, bytes: []const coral.io.Byte) ?usize {
var line_written = @as(usize, 0);
for (bytes) |byte| {
if (byte == '\n') {
ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "%.*s", stack.values.len, stack.values.ptr);
stack.clear();
line_written = 0;
continue;
}
stack.push_one(byte) catch {
coral.debug.assert(stack.drop(line_written));
return null;
};
line_written += 1;
}
return bytes.len;
}
}.write);
}
pub fn run_app(base_file_system: file.System) void { pub fn run_app(base_file_system: file.System) void {
defer heap.trace_leaks(); defer heap.trace_leaks();
const Logger = struct { var log_buffer = coral.list.ByteStack{.allocator = heap.allocator};
const Self = @This();
fn log(_: *const Self, message: []const u8) void { defer log_buffer.deinit();
ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "%.*s", message.len, message.ptr);
}
};
var script_environment = kym.Environment.init(heap.allocator, .{ var script_env = kym.RuntimeEnv.init(heap.allocator, stack_as_log_writer(&log_buffer), .{
.values_max = 512, .stack_max = 512,
.calls_max = 512, .calls_max = 512,
.reporter = kym.Environment.Reporter.bind(Logger, &.{}, Logger.log),
}) catch { }) catch {
return ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "failed to initialize Kym vm\n"); return ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "failed to initialize Kym vm\n");
}; };
defer script_environment.deinit(); defer script_env.deinit();
const app_file_name = "app.ona"; const app_file_name = "app.ona";
var app_manifest = AppManifest{}; var app_manifest = AppManifest{};
app_manifest.load_script(&script_environment, base_file_system, app_file_name) catch { app_manifest.load_script(&script_env, base_file_system, app_file_name) catch {
return ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "failed to load %s\n", app_file_name); return ext.SDL_LogError(ext.SDL_LOG_CATEGORY_APPLICATION, "failed to load %s\n", app_file_name);
}; };