スタックマシンVMを実装する——バイトコードを解釈実行するfetch-decode-executeループ

pub struct Vm {
    chunk: Chunk,
    ip: usize,
    stack: Vec<Value>,
}

pub fn run(&mut self) -> Result<(), RuntimeError> {
    loop {
        let line = self.chunk.lines[self.ip];
        match self.read_op() {
            OpCode::Constant => {
                let value = self.read_constant();
                self.push(value);
            }
            // ...(以下、全命令に対応する分岐が続く)
            OpCode::Return => return Ok(()),
        }
    }
}

fn exec_binary_arith(&mut self, op_byte: u8, line: usize) -> Result<(), RuntimeError> {
    let op = OpCode::decode(op_byte);
    let right = self.pop();
    let left = self.pop();
    let result = match (left, right) {
        (Value::Int(a), Value::Int(b)) => Value::Int(self.int_arith(op, a, b, line)?),
        (Value::Float(a), Value::Float(b)) => Value::Float(float_arith(op, a, b)),
        (left, right) => {
            unreachable!("type checker guarantees matching numeric operands, got {left:?} and {right:?}")
        }
    };
    self.push(result);
    Ok(())
}

fn exec_compare(&mut self, op_byte: u8) {
    let op = OpCode::decode(op_byte);
    let right = self.pop();
    let left = self.pop();
    let result = match (left, right) {
        (Value::Int(a), Value::Int(b)) => compare_ordered(op, a, b),
        (Value::Float(a), Value::Float(b)) => compare_ordered(op, a, b),
        (left, right) => unreachable!("..."),
    };
    self.push(Value::Bool(result));
}

fn compare_ordered<T: PartialOrd>(op: OpCode, a: T, b: T) -> bool {
    match op {
        OpCode::Lt => a < b,
        OpCode::LtEq => a <= b,
        OpCode::Gt => a > b,
        OpCode::GtEq => a >= b,
        _ => unreachable!(),
    }
}

fn int_arith(&self, op: OpCode, a: i64, b: i64, line: usize) -> Result<i64, RuntimeError> {
    match op {
        OpCode::Add => a.checked_add(b).ok_or_else(|| self.error(line, "integer overflow".to_string())),
        OpCode::Sub => a.checked_sub(b).ok_or_else(|| self.error(line, "integer overflow".to_string())),
        OpCode::Mul => a.checked_mul(b).ok_or_else(|| self.error(line, "integer overflow".to_string())),
        OpCode::Div if b == 0 => Err(self.error(line, "division by zero".to_string())),
        OpCode::Div => a.checked_div(b).ok_or_else(|| self.error(line, "integer overflow".to_string())),
        OpCode::Mod if b == 0 => Err(self.error(line, "division by zero".to_string())),
        OpCode::Mod => a.checked_rem(b).ok_or_else(|| self.error(line, "integer overflow".to_string())),
        _ => unreachable!(),
    }
}

fn exec_index(&mut self, line: usize) -> Result<(), RuntimeError> {
    let index = self.pop();
    let array = self.pop();
    let (Value::Array(items), Value::Int(index)) = (array, index) else {
        unreachable!("type checker guarantees an array and an int index")
    };
    let value = usize::try_from(index)
        .ok()
        .and_then(|index| items.get(index))
        .ok_or_else(|| self.error(line, format!("array index out of bounds: {index}")))?;
    self.push(value.clone());
    Ok(())
}

OpCode::JumpIfFalse => {
    let offset = self.read_u16();
    let Value::Bool(condition) = self.peek(0) else {
        unreachable!("type checker guarantees a bool condition");
    };
    if !condition {
        self.ip += offset as usize;
    }
}

self.compile_expr(condition, line, column)?;
let then_jump = self.emit_jump(OpCode::JumpIfFalse, line);
self.chunk.write_op(OpCode::Pop, line); // ← 条件値を捨てるのはこちらの役目

#[test]
fn arithmetic_on_locals() {
    let vm = run("let x = 1 + 2 * 3;");
    assert_eq!(vm.stack()[0], Value::Int(7));
}

#[test]
fn if_true_branch_runs_and_else_branch_is_skipped() {
    assert!(try_run("if (true) { 1; } else { let bug = 1 / 0; }").is_ok());
}

#[test]
fn for_loop_continue_skips_the_rest_of_the_body() {
    // continueが正しくジャンプしなければ、n == 2のときに直後のifも
    // 実行されてゼロ除算に到達してしまう。
    assert!(try_run(
        "for (n in [1, 2, 3]) { \
             if (n == 2) { continue; } \
             if (n == 2) { let bug = 1 / 0; } \
         }"
    )
    .is_ok());
}

let a = 10;
let b = 3;
let sum = a + b;
let quotient = a / b;
let remainder = a % b;
let is_greater = a > b;

$ cargo run -- examples/arithmetic.na
stack after execution: [Int(10), Int(3), Int(13), Int(3), Int(1), Bool(true)]

$ cargo run -- examples/arithmetic.na
na: runtime error (4): division by zero

println!("stack after execution: {:?}", vm.stack());