use crate::{Chunk, Op, VmError, eval};
use alloc::vec::Vec;
use value_lang::Value;
#[derive(Debug, Default)]
pub struct Vm {
registers: Vec<Value>,
}
impl Vm {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn with_capacity(registers: u16) -> Self {
Self {
registers: Vec::with_capacity(registers as usize),
}
}
#[must_use = "the run's result value is the point of executing the chunk"]
pub fn run(&mut self, chunk: &Chunk) -> Result<Value, VmError> {
self.registers.clear();
self.registers
.resize(chunk.registers() as usize, Value::nil());
let code = chunk.code();
let constants = chunk.constants();
let end = code.len();
let mut pc: usize = 0;
loop {
let op = *code.get(pc).ok_or(VmError::NoTerminator)?;
match op {
Op::Return { src } => return self.get(src),
Op::Halt => return Ok(Value::nil()),
Op::Jump { target } => {
pc = jump_target(target, end)?;
continue;
}
Op::JumpIfTrue { cond, target } => {
if eval::cond(self.get(cond)?, "jump-if-true")? {
pc = jump_target(target, end)?;
continue;
}
}
Op::JumpIfFalse { cond, target } => {
if !eval::cond(self.get(cond)?, "jump-if-false")? {
pc = jump_target(target, end)?;
continue;
}
}
Op::Move { dst, src } => {
let v = self.get(src)?;
self.set(dst, v)?;
}
Op::LoadConst { dst, index } => {
let v = *constants
.get(index as usize)
.ok_or(VmError::BadConstant(index))?;
self.set(dst, v)?;
}
Op::LoadNil { dst } => self.set(dst, Value::nil())?,
Op::LoadBool { dst, val } => self.set(dst, Value::bool(val))?,
Op::LoadInt { dst, val } => self.set(dst, Value::int(val))?,
Op::Add { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::add)?,
Op::Sub { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::sub)?,
Op::Mul { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::mul)?,
Op::Div { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::div)?,
Op::Rem { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::rem)?,
Op::Neg { dst, src } => {
let v = eval::neg(self.get(src)?)?;
self.set(dst, v)?;
}
Op::Eq { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::eq_op)?,
Op::Ne { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::ne_op)?,
Op::Lt { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::lt)?,
Op::Le { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::le)?,
Op::Gt { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::gt)?,
Op::Ge { dst, lhs, rhs } => self.binop(dst, lhs, rhs, eval::ge)?,
Op::Not { dst, src } => {
let v = eval::not(self.get(src)?)?;
self.set(dst, v)?;
}
}
pc += 1;
}
}
#[inline]
fn get(&self, r: u16) -> Result<Value, VmError> {
self.registers
.get(r as usize)
.copied()
.ok_or(VmError::BadRegister(r))
}
#[inline]
fn set(&mut self, r: u16, value: Value) -> Result<(), VmError> {
let slot = self
.registers
.get_mut(r as usize)
.ok_or(VmError::BadRegister(r))?;
*slot = value;
Ok(())
}
#[inline]
fn binop(
&mut self,
dst: u16,
lhs: u16,
rhs: u16,
f: fn(Value, Value) -> Result<Value, VmError>,
) -> Result<(), VmError> {
let a = self.get(lhs)?;
let b = self.get(rhs)?;
let v = f(a, b)?;
self.set(dst, v)
}
}
#[inline]
fn jump_target(target: u32, end: usize) -> Result<usize, VmError> {
let t = target as usize;
if t >= end {
Err(VmError::BadJump(target))
} else {
Ok(t)
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used)]
use super::*;
fn run(ops: &[Op], constants: &[Value]) -> Result<Value, VmError> {
let mut chunk = Chunk::new();
for &v in constants {
let _ = chunk.constant(v);
}
for &op in ops {
let _ = chunk.emit(op);
}
Vm::new().run(&chunk)
}
#[test]
fn test_return_yields_register_value() {
let out = run(
&[Op::LoadInt { dst: 0, val: 42 }, Op::Return { src: 0 }],
&[],
)
.unwrap();
assert_eq!(out.as_int(), Some(42));
}
#[test]
fn test_halt_yields_nil() {
let out = run(&[Op::Halt], &[]).unwrap();
assert!(out.is_nil());
}
#[test]
fn test_load_const_reads_pool() {
let out = run(
&[Op::LoadConst { dst: 0, index: 0 }, Op::Return { src: 0 }],
&[Value::float(2.5)],
)
.unwrap();
assert_eq!(out.as_float(), Some(2.5));
}
#[test]
fn test_arithmetic_chain() {
let out = run(
&[
Op::LoadInt { dst: 0, val: 4 },
Op::LoadInt { dst: 1, val: 5 },
Op::Mul {
dst: 0,
lhs: 0,
rhs: 1,
},
Op::LoadInt { dst: 1, val: 2 },
Op::Sub {
dst: 0,
lhs: 0,
rhs: 1,
},
Op::Return { src: 0 },
],
&[],
)
.unwrap();
assert_eq!(out.as_int(), Some(18));
}
#[test]
fn test_conditional_branch_taken() {
let out = run(
&[
Op::LoadInt { dst: 0, val: 1 },
Op::LoadInt { dst: 1, val: 2 },
Op::Lt {
dst: 2,
lhs: 0,
rhs: 1,
},
Op::JumpIfFalse { cond: 2, target: 6 },
Op::LoadInt { dst: 0, val: 10 },
Op::Return { src: 0 },
Op::LoadInt { dst: 0, val: 20 },
Op::Return { src: 0 },
],
&[],
)
.unwrap();
assert_eq!(out.as_int(), Some(10));
}
#[test]
fn test_loop_sums_with_back_edge() {
let mut chunk = Chunk::new();
let _ = chunk.emit(Op::LoadInt { dst: 0, val: 0 });
let _ = chunk.emit(Op::LoadInt { dst: 1, val: 1 });
let _ = chunk.emit(Op::LoadInt { dst: 2, val: 5 });
let _ = chunk.emit(Op::LoadInt { dst: 3, val: 1 });
let cond_at = chunk.emit(Op::Le {
dst: 4,
lhs: 1,
rhs: 2,
});
let exit_branch = chunk.emit(Op::JumpIfFalse { cond: 4, target: 0 });
let _ = chunk.emit(Op::Add {
dst: 0,
lhs: 0,
rhs: 1,
});
let _ = chunk.emit(Op::Add {
dst: 1,
lhs: 1,
rhs: 3,
});
let _ = chunk.emit(Op::Jump { target: cond_at });
let exit = chunk.emit(Op::Return { src: 0 });
assert!(chunk.patch(
exit_branch,
Op::JumpIfFalse {
cond: 4,
target: exit,
},
));
assert_eq!(Vm::new().run(&chunk).unwrap().as_int(), Some(15));
}
#[test]
fn test_no_terminator_errors() {
assert_eq!(
run(&[Op::LoadInt { dst: 0, val: 1 }], &[]),
Err(VmError::NoTerminator)
);
}
#[test]
fn test_empty_chunk_errors() {
assert_eq!(Vm::new().run(&Chunk::new()), Err(VmError::NoTerminator));
}
#[test]
fn test_bad_constant_index_errors() {
assert_eq!(
run(
&[Op::LoadConst { dst: 0, index: 3 }, Op::Return { src: 0 }],
&[]
),
Err(VmError::BadConstant(3))
);
}
#[test]
fn test_out_of_range_jump_errors() {
assert_eq!(
run(&[Op::Jump { target: 99 }], &[]),
Err(VmError::BadJump(99))
);
}
#[test]
fn test_branch_on_non_bool_type_mismatch() {
assert_eq!(
run(
&[
Op::LoadInt { dst: 0, val: 1 },
Op::JumpIfTrue { cond: 0, target: 0 },
Op::Halt,
],
&[],
),
Err(VmError::TypeMismatch { op: "jump-if-true" })
);
}
#[test]
fn test_vm_reuse_resets_registers() {
let mut vm = Vm::new();
let first = {
let mut c = Chunk::new();
let _ = c.emit(Op::LoadInt { dst: 0, val: 7 });
let _ = c.emit(Op::Return { src: 0 });
vm.run(&c).unwrap()
};
assert_eq!(first.as_int(), Some(7));
let mut c = Chunk::new();
let _ = c.emit(Op::LoadInt { dst: 5, val: 1 });
let _ = c.emit(Op::Return { src: 0 });
assert!(vm.run(&c).unwrap().is_nil());
}
}