So You Want to Build a Language VM - Part 18 - PIDs

/// Virtual machine struct that will execute bytecode
#[derive(Default, Clone)]
pub struct VM {
    /// Array that simulates having hardware registers
    pub registers: [i32; 32],
    /// Program counter that tracks which byte is being executed
    pc: usize,
    /// The bytecode of the program being run
    pub program: Vec<u8>,
    /// Used for heap memory
    heap: Vec<u8>,
    /// Contains the remainder of modulo division ops
    remainder: usize,
    /// Contains the result of the last comparison operation
    equal_flag: bool,
    /// Contains the read-only section data
    ro_data: Vec<u8>,
    /// Is a unique, randomly generated UUID for identifying this VM
    id: Uuid,
}

/// Creates and returns a new VM
pub fn new() -> VM {
    VM {
        registers: [0; 32],
        program: vec![],
        ro_data: vec![],
        heap: vec![],
        pc: 0,
        remainder: 0,
        equal_flag: false,
        id: Uuid::new_v4()
    }
}

use chrono::prelude::*;

#[derive(Clone, Debug)]
pub enum VMEventType {
    Start,
    GracefulStop,
    Crash
}

#[derive(Clone, Debug)]
pub struct VMEvent {
    event: VMEventType,
    at: DateTime<Utc>
}

/// Wraps execution in a loop so it will continue to run until done or there is an error
/// executing instructions.
pub fn run(&mut self) -> u32 {
    self.events.push(VMEvent{event: VMEventType::Start, at: Utc::now()});
    // TODO: Should setup custom errors here
    if !self.verify_header() {
        self.events.push(VMEvent{event: VMEventType::Crash, at: Utc::now()});
        println!("Header was incorrect");
        return 1;
    }
    // If the header is valid, we need to change the PC to be at bit 65.
    self.pc = 64;
    let mut is_done = false;
    while !is_done {
        is_done = self.execute_instruction();
    }
    self.events.push(VMEvent{event: VMEventType::Stop, at: Utc::now()});
    0
}

fn execute_instruction(&mut self) -> u32

if self.pc >= self.program.len() {
    return 1;
}

Opcode::HLT => {
    println!("HLT encountered");
    return 0;
}
Opcode::IGL => {
    println!("Illegal instruction encountered");
    return 1;
}

fn execute_instruction(&mut self) -> u32 {
    if self.pc >= self.program.len() {
        return 1;
    }
    match self.decode_opcode() {
        Opcode::LOAD => {
            let register = self.next_8_bits() as usize;
            let number = u32::from(self.next_16_bits());
            self.registers[register] = number as i32;
        }
        // <snip a lot of other opcodes
    };
    0
}

pub fn run(&mut self) -> u32 {
    self.events.push(VMEvent{event: VMEventType::Start, at: Utc::now()});
    // TODO: Should setup custom errors here
    if !self.verify_header() {
        self.events.push(VMEvent{event: VMEventType::Crash{code: 1}, at: Utc::now()});
        println!("Header was incorrect");
        return 1;
    }
    // If the header is valid, we need to change the PC to be at bit 65.
    self.pc = 64;
    let mut is_done = 0;
    while is_done == 0 {
        is_done = self.execute_instruction();
    }
    self.events.push(VMEvent{event: VMEventType::GracefulStop{code: is_done}, at: Utc::now()});
    0
}

/// Wraps execution in a loop so it will continue to run until done or there is an error
/// executing instructions.
pub fn run(&mut self) -> u32 {
    self.events.push(VMEvent{event: VMEventType::Start, at: Utc::now()});
    // TODO: Should setup custom errors here
    if !self.verify_header() {
        self.events.push(VMEvent{event: VMEventType::Crash{code: 1}, at: Utc::now()});
        println!("Header was incorrect");
        return 1;
    }
    // If the header is valid, we need to change the PC to be at bit 65.
    self.pc = 64;
    let mut is_done = None;
    while is_done.is_none() {
        is_done = self.execute_instruction();
    }
    self.events.push(VMEvent{event: VMEventType::GracefulStop{code: is_done.unwrap()}, at: Utc::now()});
    0
}

fn execute_instruction(&mut self) -> Option<u32> {
    if self.pc >= self.program.len() {
        return Some(1);
    }

pub fn run(&mut self) -> u32 {
    // <snip>
    None
}

let program = asm.assemble(&program);
match program {
    Ok(p) => {
        vm.add_bytes(p);
        vm.run();
        std::process::exit(0);
    },
    Err(_e) => {

    }
}

match program {
    Ok(p) => {
        vm.add_bytes(p);
        let events = vm.run();
        println!("VM Events");
        println!("--------------------------");
        for event in &events {
            println!("{:#?}", event);
        };
        std::process::exit(0);
    },
    Err(_e) => {

    }