5.2 疊代器式的堆疊虛擬機：以 Rust 實作#

loop {
    let instr = code[pc];        // 取指
    match instr {                // 譯碼 + 分派
        Instr::Add => { ... }    // 執行
        Instr::Jump(t) => { pc = t; continue; }
        // ...
    }
    pc += 1;
}

pub struct Vm {
    pub stack: Vec<Value>,       // 運算元堆疊
    pub frames: Vec<Frame>,      // 呼叫幀
    pc: usize,
}

pub struct Stack {
    data: Vec<Value>,     // 只用來管理生命週期
    sp: usize,            // 堆疊指標
}

impl Stack {
    pub fn new(cap: usize) -> Self {
        Stack { data: vec![Value::default(); cap], sp: 0 }
    }

    #[inline(always)]
    pub fn push(&mut self, v: Value) -> Result<(), VmError> {
        if self.sp >= self.data.len() { return Err(VmError::StackOverflow); }
        self.data[self.sp] = v;
        self.sp += 1;
        Ok(())
    }

    #[inline(always)]
    pub fn pop(&mut self) -> Result<Value, VmError> {
        if self.sp == 0 { return Err(VmError::StackUnderflow); }
        self.sp -= 1;
        Ok(unsafe { std::ptr::read(&self.data[self.sp]) })  // 移動語意
    }
}

pub struct Frame {
    pub closure: Rc<Closure>,
    pub pc: usize,             // 返回後從哪繼續
    pub slots: Vec<Value>,     // 區域變數
    pub base: usize,           // 運算元堆疊的幀基準
}

impl Vm {
    fn call(&mut self, nargs: u8) -> Result<(), VmError> {
        let n = nargs as usize;
        let stack_len = self.stack.len();
        if stack_len < n + 1 { return Err(VmError::StackUnderflow); }

        let callee = self.stack[stack_len - n - 1].clone();
        let f = match callee {
            Value::Fn(f) => f,
            v => return Err(VmError::TypeError { expected: "fn", got: format!("{v:?}") }),
        };

        // 參數從運算元堆疊轉移到幀槽
        let args: Vec<Value> = self.stack.split_off(stack_len - n);
        self.stack.pop();  // 函式值

        self.frames.push(Frame {
            closure: f.clone(),
            pc: 0,
            slots: {
                let mut s = vec![Value::default(); f.proto.n_slots as usize];
                for (i, a) in args.into_iter().enumerate() { s[i] = a; }
                s
            },
            base: self.stack.len(),
        });
        Ok(())
    }

    fn ret(&mut self) -> Result<Option<Value>, VmError> {
        let ret = self.stack.pop().ok_or(VmError::StackUnderflow)?;
        self.frames.pop();
        // 幀回收：slots 連同局部變數一起 drop（區域 GC 的最簡形態）
        if self.frames.is_empty() { return Ok(Some(ret)); }
        self.stack.push(ret);
        Ok(None)
    }
}

Load     38%
Add      22%
Call     12%
Const    10%
Store     8%
其他     10%

#[derive(Debug, Clone)]
pub enum Instr {
    // ...原有指令...
    /// superinstruction: Load a; Load b; Add
    AddLocal2 { a: u16, b: u16 },
}

// compiler: 觀察 Load-Load-Add 的模式
fn try_superinstruction(&self, window: &[&Expr]) -> Option<Instr> {
    match (window.get(0)?, window.get(1)?, window.get(2)?) {
        (Expr::Var{..}, Expr::Var{..}, Expr::BinOp{op: BinOp::Add, ..}) => {
            // 兩個變數相加 → 合併成一條
            Some(Instr::AddLocal2 { a: ..., b: ... })
        }
        _ => None,
    }
}

Instr::AddLocal2 { a, b } => {
    let f = self.frames.last().unwrap();
    let va = f.slots[*a as usize].as_num().map_err(|e| VmError::TypeError { expected: "num", got: e })?;
    let vb = f.slots[*b as usize].as_num().map_err(|e| VmError::TypeError { expected: "num", got: e })?;
    self.stack.push(Value::Num(va.wrapping_add(vb)));
}

pub type Builtin = fn(&mut Vm, &[Value]) -> Result<Value, String>;

pub fn install_builtins(builtins: &mut HashMap<String, Value>) {
    builtins.insert("print".into(), Value::Builtin(builtin_print));
    builtins.insert("clock".into(), Value::Builtin(builtin_clock));
}

fn builtin_print(vm: &mut Vm, args: &[Value]) -> Result<Value, String> {
    for a in args { print!("{a:?} "); }
    println!();
    Ok(Value::default())
}