ona/source/ona/kym/Chunk.zig

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