Rust虚拟机Demo

#![allow(warnings)]

// 定义虚拟机的指令集
#[derive(Debug, Clone, Copy)]
enum Instruction {
    Push(i32),   // 将数值压入栈
    Add,         // 栈顶的两个元素相加
    Sub,         // 栈顶的两个元素相减
    Mul,         // 栈顶的两个元素相乘
    Div,         // 栈顶的两个元素相除
    Pop,         // 弹出栈顶元素
    Halt,        // 停止虚拟机
}

// 定义虚拟机结构体
struct VM {
    stack: Vec<i32>, // 模拟栈
    ip: usize,       // 指令指针（Instruction Pointer）
    program: Vec<Instruction>, // 存储指令集
}

impl VM {
    // 初始化虚拟机
    fn new(program: Vec<Instruction>) -> Self {
        VM {
            stack: Vec::new(),
            ip: 0,
            program,
        }
    }

    // 启动虚拟机
    fn run(&mut self) {
        loop {
            if self.ip >= self.program.len() {
                break;
            }

            // 获取当前指令
            let instruction = self.program[self.ip];
            self.ip += 1;

            match instruction {
                Instruction::Push(value) => self.stack.push(value),
                Instruction::Add => self.execute_add(),
                Instruction::Sub => self.execute_sub(),
                Instruction::Mul => self.execute_mul(),
                Instruction::Div => self.execute_div(),
                Instruction::Pop => {
                    self.stack.pop();
                }
                Instruction::Halt => {
                    println!("Halted");
                    break;
                }
            }
        }
    }

    // 加法指令
    fn execute_add(&mut self) {
        if let (Some(b), Some(a)) = (self.stack.pop(), self.stack.pop()) {
            self.stack.push(a + b);
        } else {
            println!("Error: Stack underflow");
        }
    }

    // 减法指令
    fn execute_sub(&mut self) {
        if let (Some(b), Some(a)) = (self.stack.pop(), self.stack.pop()) {
            self.stack.push(a - b);
        } else {
            println!("Error: Stack underflow");
        }
    }

    // 乘法指令
    fn execute_mul(&mut self) {
        if let (Some(b), Some(a)) = (self.stack.pop(), self.stack.pop()) {
            self.stack.push(a * b);
        } else {
            println!("Error: Stack underflow");
        }
    }

    // 除法指令
    fn execute_div(&mut self) {
        if let (Some(b), Some(a)) = (self.stack.pop(), self.stack.pop()) {
            if b != 0 {
                self.stack.push(a / b);
            } else {
                println!("Error: Division by zero");
                self.stack.push(a); // 保持栈状态不变
                self.stack.push(b);
            }
        } else {
            println!("Error: Stack underflow");
        }
    }
}

fn main() {
    // 一个简单的程序：Push 10, Push 20, Add, Pop, Halt
    let program = vec![
        Instruction::Push(10),
        Instruction::Push(20),
        Instruction::Add,
        Instruction::Pop,
        Instruction::Halt,
    ];

    let mut vm = VM::new(program);
    vm.run();
}

推荐几款学习编程的免费平台

免费在线开发平台（https://docs.ltpp.vip/LTPP/）

免费公益服务器（https://docs.ltpp.vip/LTPP-SHARE/linux.html）

免费公益MYSQL（https://docs.ltpp.vip/LTPP-SHARE/mysql.html）

免费在线WEB代码编辑器（https://docs.ltpp.vip/LTPP-WEB-IDE/）

免费二维码生成器（https://docs.ltpp.vip/LTPP-QRCODE/）