use crate::ir::{Arith, Cmd, MsgOp, Num, Rel};
use fusevm::{Chunk, ChunkBuilder, Op, Value};
pub mod ops {
pub const MSG_APPEND: u16 = 4000;
pub const MSG_FLUSH: u16 = 4001;
}
pub const COUNT_SLOTS: u16 = 256;
pub struct Compiler {
b: ChunkBuilder,
}
impl Compiler {
pub fn new() -> Self {
Self {
b: ChunkBuilder::new(),
}
}
pub fn compile(mut self, cmds: &[Cmd]) -> Chunk {
for reg in 0..COUNT_SLOTS {
self.b.emit(Op::LoadInt(0), 0);
self.b.emit(Op::SetSlot(reg), 0);
}
self.block(cmds);
self.b.build()
}
fn block(&mut self, cmds: &[Cmd]) {
for c in cmds {
self.cmd(c);
}
}
fn cmd(&mut self, c: &Cmd) {
match c {
Cmd::SetCount(reg, n) => {
self.num(n);
self.b.emit(Op::SetSlot(slot(*reg)), 0);
}
Cmd::Arith(op, reg, n) => {
self.b.emit(Op::GetSlot(slot(*reg)), 0);
self.num(n);
let native = match op {
Arith::Add => Op::Add,
Arith::Mul => Op::Mul,
Arith::Div => Op::Div,
};
self.b.emit(native, 0);
if matches!(op, Arith::Div) {
self.b.emit(Op::TruncInt, 0);
}
self.b.emit(Op::SetSlot(slot(*reg)), 0);
}
Cmd::Message(msg) => {
self.msg_ops(msg);
self.b.emit(Op::CallBuiltin(ops::MSG_FLUSH, 0), 0);
self.b.emit(Op::Pop, 0);
}
Cmd::Group { saves, body } => {
for reg in saves {
self.b.emit(Op::GetSlot(slot(*reg)), 0);
}
self.block(body);
for reg in saves.iter().rev() {
self.b.emit(Op::SetSlot(slot(*reg)), 0);
}
}
Cmd::IfNum {
left,
rel,
right,
then_branch,
else_branch,
} => {
self.num(left);
self.num(right);
self.b.emit(
match rel {
Rel::Less => Op::NumLt,
Rel::Equal => Op::NumEq,
Rel::Greater => Op::NumGt,
},
0,
);
self.branch(then_branch, else_branch);
}
Cmd::IfOdd {
value,
then_branch,
else_branch,
} => {
self.num(value);
self.b.emit(Op::LoadInt(2), 0);
self.b.emit(Op::Mod, 0);
self.b.emit(Op::LoadInt(0), 0);
self.b.emit(Op::NumEq, 0);
self.b.emit(Op::LogNot, 0);
self.branch(then_branch, else_branch);
}
}
}
fn msg_ops(&mut self, msg: &[MsgOp]) {
for m in msg {
match m {
MsgOp::Text(t) => {
let k = self.b.add_constant(Value::Str(t.clone().into()));
self.b.emit(Op::LoadConst(k), 0);
self.b.emit(Op::CallBuiltin(ops::MSG_APPEND, 1), 0);
self.b.emit(Op::Pop, 0);
}
MsgOp::Number(n) => {
self.num(n);
self.b.emit(Op::CallBuiltin(ops::MSG_APPEND, 1), 0);
self.b.emit(Op::Pop, 0);
}
MsgOp::If {
left,
rel,
right,
then_ops,
else_ops,
} => {
self.num(left);
self.num(right);
self.b.emit(
match rel {
Rel::Less => Op::NumLt,
Rel::Equal => Op::NumEq,
Rel::Greater => Op::NumGt,
},
0,
);
self.msg_branch(then_ops, else_ops);
}
MsgOp::IfOdd {
value,
then_ops,
else_ops,
} => {
self.num(value);
self.b.emit(Op::LoadInt(2), 0);
self.b.emit(Op::Mod, 0);
self.b.emit(Op::LoadInt(0), 0);
self.b.emit(Op::NumEq, 0);
self.b.emit(Op::LogNot, 0);
self.msg_branch(then_ops, else_ops);
}
}
}
}
fn msg_branch(&mut self, then_ops: &[MsgOp], else_ops: &[MsgOp]) {
let to_else = self.b.emit(Op::JumpIfFalse(0), 0);
self.msg_ops(then_ops);
let over = self.b.emit(Op::Jump(0), 0);
let at = self.b.current_pos();
self.b.patch_jump(to_else, at);
self.msg_ops(else_ops);
let end = self.b.current_pos();
self.b.patch_jump(over, end);
}
fn branch(&mut self, then_branch: &[Cmd], else_branch: &[Cmd]) {
let to_else = self.b.emit(Op::JumpIfFalse(0), 0);
self.block(then_branch);
let over_else = self.b.emit(Op::Jump(0), 0);
let else_at = self.b.current_pos();
self.b.patch_jump(to_else, else_at);
self.block(else_branch);
let end = self.b.current_pos();
self.b.patch_jump(over_else, end);
}
fn num(&mut self, n: &Num) {
match n {
Num::Literal(v) => {
self.b.emit(Op::LoadInt(*v), 0);
}
Num::Count(reg) => {
self.b.emit(Op::GetSlot(slot(*reg)), 0);
}
}
}
}
fn slot(reg: i64) -> u16 {
u16::try_from(reg).unwrap_or(0).min(COUNT_SLOTS - 1)
}
impl Default for Compiler {
fn default() -> Self {
Self::new()
}
}