vm 0.1.0

A general purpose virtual machine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use crate::error::Error;
use crate::get_register_value;
use crate::instructions::{Execute, Operand};
use crate::processor::Processor;
use crate::register::Width;

#[repr(u64)]
#[derive(Debug, PartialEq, Eq)]
/// Enum containing the call indices for external code.
pub enum CallIndex {
    /// Prints the processor using the Debug format.
    PrintProcessor = 0,
}

impl From<u64> for CallIndex {
    fn from(value: u64) -> Self {
        match value {
            0 => CallIndex::PrintProcessor,

            _ => todo!(),
        }
    }
}

#[derive(Debug, Default)]
/// Call into external code to access the processor in a mutable state.
pub struct Call {
    call_index: Operand,
}

impl Call {
    #[must_use]
    /// Constructs a new [`Call`].
    pub fn new(call_index: Operand) -> Self {
        Call { call_index }
    }
}

impl Execute for Call {
    fn execute(&self, processor: &mut Processor) -> Result<(), Error> {
        let call_index: CallIndex = match self.call_index {
            Operand::Value(value) => value,
            Operand::Register(ref register) => get_register_value!(processor, register),

            _ => return Err(Error::InvalidOperand),
        }
        .into();

        match call_index {
            CallIndex::PrintProcessor => println!("{processor:#?}"),
        }

        Ok(())
    }
}