Struct maikor_vm_core::VM

pub struct VM {

    pub registers: [u8; 9],
    pub pc: u16,
    pub memory: [u8; 65536],
    pub ram_banks: Vec<[u8; 4200]>,
    pub code_banks: Vec<[u8; 4200]>,
    pub save_banks: Vec<[u8; 4096]>,
    pub controller_graphics_banks: Vec<[u8; 88]>,
    pub save_dirty_flag: [bool; 16],
    pub atlas_banks: Vec<[u8; 4000]>,
    pub error: Option<String>,
    pub halted: bool,
    pub op_executed: usize,
    pub cycles_executed: usize,
    pub sound: Sound,
    /* private fields */
}

Fields

registers: [u8; 9]

Order is AH, AL, BH, BL, CH, CL, DH, DL, FLG Extended registers (AX, BX, etc) are made of H+L, i.e. AX is [AH,AL]

pc: u16

Program Counter, address/index of byte currently being executed

memory: [u8; 65536]

All changes MUST go through debug_set_mem or debug_set_mem_range otherwise banks won’t change, etc

ram_banks: Vec<[u8; 4200]>

code_banks: Vec<[u8; 4200]>

save_banks: Vec<[u8; 4096]>

controller_graphics_banks: Vec<[u8; 88]>

save_dirty_flag: [bool; 16]

if a flag is true, then the matching data in save_banks should be written to disk and the flag set to false (also, if memory[SAVE_CONTROL] & AUTO_SAVE is 0, then memory[SAVE_CONTROL] should set to 0)

atlas_banks: Vec<[u8; 4000]>

error: Option<String>

error message from EHALT

halted: bool

if true the VM has stopped (EoF or error) and can’t continue

op_executed: usize

Count of operations executed this session

cycles_executed: usize

Count of cycles executed this session

sound: Sound

Implementations

impl VM

pub fn check_flag(&self, flag: u8) -> bool

pub fn set_flag(&mut self, flag: u8)

pub fn clear_flag(&mut self, flag: u8)

impl VM

pub fn set_flags_byte(&mut self, value: u8)

pub fn set_math_flags_byte(
    &mut self,
    value: u8,
    set_carry: bool,
    set_overflow: bool
)

pub fn set_cmp_flags_byte(&mut self, lhs: u8, rhs: u8, signed: bool)

impl VM

pub fn set_flags_word(&mut self, value: u16)

pub fn set_math_flags_word(
    &mut self,
    value: u16,
    set_carry: bool,
    set_overflow: bool
)

pub fn set_cmp_flags_word(&mut self, lhs: u16, rhs: u16, signed: bool)

impl VM

Word memory access

pub fn read_word_mem(&self, addr: u16) -> (u16, usize)

Get number in memory at address Returns the value and cycles used

pub fn write_word_mem(&mut self, addr: u16, value: u16) -> usize

impl VM

Byte memory access

pub fn read_byte_mem(&self, addr: u16) -> (u8, usize)

Get number in memory at address Returns the value and cycles used

pub fn write_byte_mem(&mut self, addr: u16, value: u8) -> usize

pub fn get_memory_mut(&mut self, start: usize, len: usize) -> &mut [u8]

impl VM

Word register access

pub fn read_word_reg_value(&mut self, reg: &Register) -> (u16, usize)

Get number in word reg, ignoring any addressing Returns the value and cycles used

pub fn write_word_reg_value(&mut self, reg: &Register, value: u16) -> usize

Write number in word reg, ignoring any addressing Returns the cycles used

pub fn read_word_reg(&mut self, reg: &Register, offset: i16) -> (u16, usize)

Get number from word reg, either if direct, the value in the reg if indirect, the value in memory at the address in the reg Returns the value and cycles used

pub fn write_word_reg(
    &mut self,
    reg: &Register,
    offset: i16,
    value: u16
) -> usize

Write to register, either if direct, the value in the reg if indirect, the value in memory at the address in the reg Returns the cycles used

impl VM

Byte register access

pub fn read_byte_reg_value(&mut self, reg: &Register) -> (u8, usize)

Get number in word reg, ignoring any addressing Returns the value and cycles used

pub fn write_byte_reg_value(&mut self, reg: &Register, value: u8) -> usize

Write number in word reg, ignoring any addressing Returns the cycles used

pub fn read_byte_reg(&mut self, reg: &Register, offset: i16) -> (u8, usize)

Get number from word reg, either if direct, the value in the reg if indirect, the value in memory at the address in the reg Returns the value and cycles used

pub fn write_byte_reg(
    &mut self,
    reg: &Register,
    offset: i16,
    value: u8
) -> usize

Write to register, either if direct, the value in the reg if indirect, the value in memory at the address in the reg Returns the cycles used

impl VM

pub fn get_sp(&self) -> u16

pub fn get_fp(&self) -> u16

impl VM

pub fn not_reg_byte(&mut self) -> usize

pub fn not_reg_word(&mut self) -> usize

pub fn bl_reg_reg_byte(&mut self, method: fn(_: u8, _: u8) -> u8) -> usize

pub fn bl_reg_reg_word(&mut self, method: fn(_: u16, _: u16) -> u16) -> usize

pub fn bl_reg_num_byte(&mut self, method: fn(_: u8, _: u8) -> u8) -> usize

pub fn bl_reg_num_word(&mut self, method: fn(_: u16, _: u16) -> u16) -> usize

impl VM

ADDR WORD

pub fn asl_addr_word(&mut self) -> usize

pub fn asr_addr_word(&mut self) -> usize

pub fn lsr_addr_word(&mut self) -> usize

pub fn rol_addr_word(&mut self) -> usize

pub fn ror_addr_word(&mut self) -> usize

pub fn rcl_addr_word(&mut self) -> usize

pub fn rcr_addr_word(&mut self) -> usize

impl VM

ADDR BYTE

pub fn asl_addr_byte(&mut self) -> usize

pub fn asr_addr_byte(&mut self) -> usize

pub fn lsr_addr_byte(&mut self) -> usize

pub fn rol_addr_byte(&mut self) -> usize

pub fn ror_addr_byte(&mut self) -> usize

pub fn rcl_addr_byte(&mut self) -> usize

pub fn rcr_addr_byte(&mut self) -> usize

impl VM

REG, NUM BYTE

pub fn asl_reg_num_byte(&mut self) -> usize

pub fn asr_reg_num_byte(&mut self) -> usize

pub fn lsr_reg_num_byte(&mut self) -> usize

pub fn rol_reg_num_byte(&mut self) -> usize

pub fn ror_reg_num_byte(&mut self) -> usize

pub fn rcl_reg_num_byte(&mut self) -> usize

pub fn rcr_reg_num_byte(&mut self) -> usize

impl VM

REG, NUM WORD

pub fn asl_reg_num_word(&mut self) -> usize

pub fn asr_reg_num_word(&mut self) -> usize

pub fn lsr_reg_num_word(&mut self) -> usize

pub fn rol_reg_num_word(&mut self) -> usize

pub fn ror_reg_num_word(&mut self) -> usize

pub fn rcl_reg_num_word(&mut self) -> usize

pub fn rcr_reg_num_word(&mut self) -> usize

impl VM

REG, REG BYTE

pub fn asl_reg_reg_byte(&mut self) -> usize

pub fn asr_reg_reg_byte(&mut self) -> usize

pub fn lsr_reg_reg_byte(&mut self) -> usize

pub fn rol_reg_reg_byte(&mut self) -> usize

pub fn ror_reg_reg_byte(&mut self) -> usize

pub fn rcl_reg_reg_byte(&mut self) -> usize

pub fn rcr_reg_reg_byte(&mut self) -> usize

impl VM

REG, REG WORD

pub fn asl_reg_reg_word(&mut self) -> usize

pub fn asr_reg_reg_word(&mut self) -> usize

pub fn lsr_reg_reg_word(&mut self) -> usize

pub fn rol_reg_reg_word(&mut self) -> usize

pub fn ror_reg_reg_word(&mut self) -> usize

pub fn rcl_reg_reg_word(&mut self) -> usize

pub fn rcr_reg_reg_word(&mut self) -> usize

impl VM

pub fn cmp_reg_num_byte(&mut self, signed: bool) -> usize

pub fn cmp_reg_num_word(&mut self, signed: bool) -> usize

impl VM

pub fn cpy_reg_num_byte(&mut self) -> usize

pub fn cpy_reg_reg_byte(&mut self) -> usize

pub fn cpy_reg_addr_byte(&mut self) -> usize

pub fn cpy_reg_num_word(&mut self) -> usize

pub fn cpy_reg_reg_word(&mut self) -> usize

pub fn cpy_reg_addr_word(&mut self) -> usize

pub fn cpy_addr_num_byte(&mut self) -> usize

pub fn cpy_addr_addr_byte(&mut self) -> usize

pub fn cpy_addr_reg_byte(&mut self) -> usize

pub fn cpy_addr_num_word(&mut self) -> usize

pub fn cpy_addr_addr_word(&mut self) -> usize

pub fn cpy_addr_reg_word(&mut self) -> usize

impl VM

pub fn execute(&mut self, op: u8) -> Result<(bool, usize), String>

Execute op with params Returns true if op has adjusted PC (and so VM shouldn’t automatically advance) and cycles

impl VM

pub fn jb_reg_reg(&mut self, required: bool) -> (bool, usize)

Jump based on flag state If flag state matches required then jump

pub fn jb_addr_reg(&mut self, required: bool) -> (bool, usize)

Jump based on flag state If flag state matches required then jump

pub fn jb_reg_num(&mut self, required: bool) -> (bool, usize)

Jump based on flag state If flag state matches required then jump

pub fn jb_addr_num(&mut self, required: bool) -> (bool, usize)

Jump based on flag state If flag state matches required then jump

impl VM

pub fn inc_reg_byte(&mut self) -> usize

pub fn dec_reg_byte(&mut self) -> usize

pub fn inc_reg_word(&mut self) -> usize

pub fn dec_reg_word(&mut self) -> usize

pub fn inc_addr_byte(&mut self) -> usize

pub fn dec_addr_byte(&mut self) -> usize

pub fn inc_addr_word(&mut self) -> usize

pub fn dec_addr_word(&mut self) -> usize

impl VM

pub fn jmp_addr(&mut self) -> (bool, usize)

pub fn je_addr(&mut self) -> (bool, usize)

pub fn jne_addr(&mut self) -> (bool, usize)

pub fn jl_addr(&mut self) -> (bool, usize)

pub fn jg_addr(&mut self) -> (bool, usize)

pub fn jle_addr(&mut self) -> (bool, usize)

pub fn jge_addr(&mut self) -> (bool, usize)

pub fn jmp_reg(&mut self) -> (bool, usize)

pub fn je_reg(&mut self) -> (bool, usize)

pub fn jne_reg(&mut self) -> (bool, usize)

pub fn jl_reg(&mut self) -> (bool, usize)

pub fn jg_reg(&mut self) -> (bool, usize)

pub fn jle_reg(&mut self) -> (bool, usize)

pub fn jge_reg(&mut self) -> (bool, usize)

impl VM

pub fn math_reg_num_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_reg_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_addr_num_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_addr_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_addr_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_reg_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn math_reg_num_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn math_reg_reg_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn math_addr_num_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn math_addr_reg_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn math_addr_addr_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn math_reg_addr_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

impl VM

pub fn mathc_reg_num_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_reg_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_addr_num_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_addr_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_addr_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_reg_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8, _: bool) -> (u8, bool)
) -> usize

pub fn mathc_reg_num_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

pub fn mathc_reg_reg_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

pub fn mathc_addr_num_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

pub fn mathc_addr_reg_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

pub fn mathc_addr_addr_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

pub fn mathc_reg_addr_word(
    &mut self,
    method: fn(_: u16, _: u16, _: bool) -> (u16, bool)
) -> usize

impl VM

pub fn maths_reg_num_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_reg_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_addr_num_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_addr_reg_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_addr_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_reg_addr_byte(
    &mut self,
    method: fn(_: u8, _: u8) -> (u8, bool)
) -> usize

pub fn maths_reg_num_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn maths_reg_reg_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn maths_addr_num_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn maths_addr_reg_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn maths_addr_addr_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

pub fn maths_reg_addr_word(
    &mut self,
    method: fn(_: u16, _: u16) -> (u16, bool)
) -> usize

impl VM

pub fn copy_mem(&mut self, dst: u16, src: u16, count: usize)

pub fn swap_mem(&mut self, dst: u16, src: u16, count: usize)

pub fn mem_addr_addr_byte(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_addr_addr_reg(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_addr_reg_byte(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_addr_reg_reg(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_reg_addr_byte(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_reg_addr_reg(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_reg_reg_byte(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

pub fn mem_reg_reg_reg(
    &mut self,
    method: fn(_: &mut VM, _: u16, _: u16, _: usize)
) -> usize

impl VM

pub fn swap_byte(&mut self) -> usize

pub fn swap_word(&mut self) -> usize

impl VM

pub fn pre_process(&mut self, reg: &Register, op_size: u8) -> (i16, usize)

Run Pre Inc/Dec on register Also check and read bytes for index addressing Returns address offset and cycle cost

pub fn post_process(&mut self, reg: &Register, op_size: u8) -> usize

impl VM

pub fn call_addr(&mut self) -> usize

pub fn call_reg(&mut self) -> usize

pub fn ret(&mut self) -> usize

pub fn push_reg_byte(&mut self) -> usize

pub fn push_reg_word(&mut self) -> usize

pub fn push_num_byte(&mut self) -> usize

pub fn push_num_word(&mut self) -> usize

pub fn pop_reg_byte(&mut self) -> usize

pub fn pop_reg_word(&mut self) -> usize

impl VM

pub fn new(player: Box<dyn AudioPlayer>) -> Self

Create a new VM Requires an AudioPlayer, as an example see maikor-interface

pub fn new_test() -> VM

Create an instance with a dummy audio player for testing

impl VM

pub fn load_game(
    &mut self,
    game: GameFile,
    saves: &[[u8; 4096]]
) -> Result<(), String>

Load game This only copies data to banks, it doesn’t reset PC, registers, etc Call VM::init() once before any VM::step() calls

pub fn init(&mut self)

Loads initial banks and setup sound This should be called after load_game() and any needed changes are made Once this has been called the banks and memory shouldn’t be changed by the host (except for setting flags, interrupts, etc)

impl VM

Public interface to VM

pub fn step(&mut self) -> usize

Advance VM one operation

If this fails (invalid register, etc) then VM::halted will be set to true

returns number of cycles used

pub fn trigger_interrupt(&mut self, interrupt_id: u8)

Attempt to trigger the interrupt that matches interrupt_id VM will halt if the id is invalid

pub fn execute_op(&mut self, bytes: &[u8])

Run arbitrary op, does not advance PC automatically (JMP, etc ops still work) This works by writing the bytes to a section of reserved and setting the PC to there

pub fn dump(&self) -> String

Writes registers to String

impl VM

pub fn debug_set_mem(&mut self, addr: u16, value: u8)

Set one byte in memory This will trigger interrupts, bank switching, etc

pub fn debug_set_mem_range(&mut self, addr: u16, values: &[u8])

Set bytes in memory This will trigger interrupts, bank switching, etc