Struct Registers 

pub struct Registers { /* private fields */ }

Z80 internal register values

Implementations

impl Registers

pub fn a(&self) -> u8

Returns the value of the A register

Examples found in repository

examples/simplest.rs (line 22)

fn main() {
    // Prepare the device
    let mut machine = PlainMachine::new();
    let mut cpu = Cpu::new();
    cpu.set_trace(true);

    // Load program inline or from a file with:
    //      let code = include_bytes!("XXXX.rom");
    let code = [0x3c, 0xc3, 0x00, 0x00]; // INC A, JP $0000
    for (i, e) in code.iter().enumerate() {
        machine.poke(i as u16, *e);
    }

    // Run emulation
    cpu.registers().set_pc(0x0000);
    loop {
        cpu.execute_instruction(&mut machine);

        // Examine machine state to update the hosting device as needed.
        if cpu.registers().a() == 0x10 {
            // Let's stop
            break;
        }
    }
}

examples/simplest8080.rs (line 22)

fn main() {
    // Prepare the device
    let mut machine = PlainMachine::new();
    let mut cpu = Cpu::new_8080();
    cpu.set_trace(true);

    // Load program inline or from a file with:
    //      let code = include_bytes!("XXXX.rom");
    let code = [0x3c, 0xc3, 0x00, 0x00]; // INC A, JP $0000
    for (i, e) in code.iter().enumerate() {
        machine.poke(i as u16, *e);
    }

    // Run emulation
    cpu.registers().set_pc(0x0000);
    loop {
        cpu.execute_instruction(&mut machine);

        // Examine machine state to update the hosting device as needed.
        if cpu.registers().a() == 0x10 {
            // Let's stop
            break;
        }
    }
}

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

Sets the A register

pub fn get8(&self, reg: Reg8) -> u8

Returns the value of an 8 bit register

pub fn set8(&mut self, reg: Reg8, value: u8)

Sets the value of an 8 bit register

pub fn get16(&self, rr: Reg16) -> u16

Returns the value of a 16 bit register

pub fn set16(&mut self, rr: Reg16, value: u16)

Sets the value of a 16 bit register. Changes the value of the two underlying 8 bit registers.

pub fn get_flag(&self, flag: Flag) -> bool

Returns the value of a flag

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

Sets a flag. Sets the value to true

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

Clears a flag. Sets the value to false

pub fn put_flag(&mut self, flag: Flag, value: bool)

Sets the value of a flag

pub fn pc(&self) -> u16

Returns the program counter

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

Changes the program counter

Examples found in repository

examples/simplest.rs (line 17)

fn main() {
    // Prepare the device
    let mut machine = PlainMachine::new();
    let mut cpu = Cpu::new();
    cpu.set_trace(true);

    // Load program inline or from a file with:
    //      let code = include_bytes!("XXXX.rom");
    let code = [0x3c, 0xc3, 0x00, 0x00]; // INC A, JP $0000
    for (i, e) in code.iter().enumerate() {
        machine.poke(i as u16, *e);
    }

    // Run emulation
    cpu.registers().set_pc(0x0000);
    loop {
        cpu.execute_instruction(&mut machine);

        // Examine machine state to update the hosting device as needed.
        if cpu.registers().a() == 0x10 {
            // Let's stop
            break;
        }
    }
}

examples/simplest8080.rs (line 17)

fn main() {
    // Prepare the device
    let mut machine = PlainMachine::new();
    let mut cpu = Cpu::new_8080();
    cpu.set_trace(true);

    // Load program inline or from a file with:
    //      let code = include_bytes!("XXXX.rom");
    let code = [0x3c, 0xc3, 0x00, 0x00]; // INC A, JP $0000
    for (i, e) in code.iter().enumerate() {
        machine.poke(i as u16, *e);
    }

    // Run emulation
    cpu.registers().set_pc(0x0000);
    loop {
        cpu.execute_instruction(&mut machine);

        // Examine machine state to update the hosting device as needed.
        if cpu.registers().a() == 0x10 {
            // Let's stop
            break;
        }
    }
}

examples/cpuville.rs (line 38)

fn main() {
    let mut machine = VilleMachine::new();
    let mut cpu = Cpu::new();
    let mut timed_runner = TimedRunner::default();
    timed_runner.set_mhz(&cpu, MHZ, 1000);

    // Init console
    let mut stdout = stdout();
    let stdin_channel = spawn_stdin_channel();
    let mut in_char_waiting = false;

    // Load program
    let code = TINY_BASIC;
    for (i, e) in code.iter().enumerate() {
        machine.poke(i as u16, *e);
    }

    // Init
    cpu.registers().set_pc(0x0000);
    machine.in_values[3] = 1; // TX Ready

    loop {
        timed_runner.execute(&mut cpu, &mut machine);

        if let Some(port) = machine.out_port {
            match port {
                2 => {
                    print!("{}", machine.out_value as char);
                    stdout.flush().unwrap();
                },
                3 => {},
                _ => panic!("BDOS command not implemented")
            }
            machine.out_port = None;
        }

        if let Some(port) = machine.in_port {
            match port {
                2 => {
                    in_char_waiting = false;
                },
                3 => {},
                _ => panic!("BDOS command not implemented")
            }
            machine.in_port = None;

            // Avoid 100% CPU usage waiting for input.
            if MHZ == 0.0 {
                thread::sleep(Duration::from_millis(1));  
            }
        }

        if !in_char_waiting {
            // Let's get another char if available
            match stdin_channel.try_recv() {
                Ok(key) => {
                    machine.in_values[2] = key;
                    in_char_waiting = true;
                    machine.in_values[3] = 3; // RX Ready
                },
                Err(TryRecvError::Empty) => {
                    machine.in_values[3] = 1; // RX Not ready
                },
                Err(TryRecvError::Disconnected) => {},
            }
        }
    }
}

Trait Implementations

impl Debug for Registers

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.