Struct CPU 

pub struct CPU { /* private fields */ }

The CPU is where instruction reading and execution is handled.

Contains Memory, as well as an ExecutionStack. These are used to read and execute instructions.

Implementations

impl CPU

pub fn new() -> CPU

Create a new CPU. Initializes both the memory and stack to be empty.

pub fn load_instructions( &mut self, instructions: &Vec<Instruction>, symbol: &Symbol, )

Load instructions into memory at a given symbol.

pub fn init_execution(&mut self, entrypoint: &Symbol)

Get the CPU ready to start executing code. Clears the stack and jumps to the entrypoint.

pub fn cycle(&mut self) -> Result<bool, String>

Complete one CPU cycle. Returns false iff the stack is empty. Returns an error if something goes wrong during execution. Returns true otherwise.

Each CPU cycle does the following:

• Checks if the stack is empty. If it is, return false. If not, continue.
• Reads the instructions that the ExecutionPointer at the top of the stack points to.
• If we’re done execution there, return from that block, and return true.
• Otherwise, read the instruction at the given index and execute it.
• If the instruction errors, return the error. Otherwise, return true.

One CPU cycle does not necessarily map to one instruction, as a CPU cycle is used every time we pop an execution pointer off of the stack when we are done executing those instructions. This is technically equivalent to every instruction vector having a return instruction tacked on at the end, but isn’t handled the same way.

pub fn get_memory(&self) -> Memory

Get a clone of the memory for debugging.

pub fn get_stack(&self) -> ExecutionStack

Get a clone of the stack for debugging.

Trait Implementations

impl Default for CPU

fn default() -> Self

Returns the “default value” for a type.