Struct Cpu 

pub struct Cpu {
    pub a: u8,
    pub x: u8,
    pub y: u8,
    pub sp: u8,
    pub pc: u16,
    pub status: u8,
    pub cycles: u8,
    pub bus: Box<dyn Bus>,
    pub variant: Variant,
    pub enable_illegal_opcodes: bool,
    pub current_instruction_string: String,
    pub debug: usize,
    /* private fields */
}

The emulated 6502 CPU

Fields

a: u8

The 8-bit accumulator

x: u8

The 8-bit x index register

y: u8

The 8-bit y index register

sp: u8

The 8-bit stack pointer

pc: u16

The 16-bit program counter

status: u8

The status flags

cycles: u8

The number of cycles remaining

bus: Box<dyn Bus>

The bus that the CPU is connected to

variant: Variant

The variant of the CPU

enable_illegal_opcodes: bool

Whether illegal instructions are allowed

current_instruction_string: String

The current instruction string

debug: usize

Debug modes 0: No debug 1: Print each instruction 2: Print each cycle

Implementations

impl Cpu

pub fn new(bus: Box<dyn Bus>, debug: usize) -> Cpu

Create a new CPU

pub fn reset(&mut self)

Reset the CPU

pub fn read(&self, address: u16) -> u8

Read a byte from memory

pub fn read_u16(&self, address: u16) -> u16

Read a 16-bit word from memory

pub fn write(&mut self, address: u16, value: u8)

Write a byte to memory

pub fn write_u16(&mut self, address: u16, value: u16)

Write a 16-bit word to memory

pub fn change_variant(&mut self, variant: Variant)

Set the CPU variant

pub fn set_illegal_opcodes(&mut self, value: bool)

Set the enable_illegal_opcodes flag

pub fn get_status_string(&self) -> String

Get the status string for the CPU (NV-BDIZC)

pub fn get_cycles(&self, opcode: u8) -> u8

Get the number of cycles for an instruction

pub fn irq(&mut self)

Interrupt request

pub fn nmi(&mut self)

Non-maskable interrupt request

pub fn get_register(&self, register: &str) -> u8

Get the value of a register

pub fn clock(&mut self)

Clock the CPU

pub fn get_state(&self) -> String

Get the state of the CPU