lemurs-8080 0.5.0

An emulator for the Intel 8080 microprocessor
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
56
57
58
59

pub use execution::opcode;

use core::{borrow::BorrowMut, num::Wrapping};
use crate::{Harness, Machine, bits::*};

#[cfg(not(any(doc, feature="open")))]
pub(self) mod access;
#[cfg(any(doc, feature="open"))]
pub mod access;

mod execution;

/// This struct stores the internal registers and flags of the 8080 CPU.
#[repr(C)]
#[disclose(crate)]
pub struct State {
	pc: u16,
	sp: u16,
	register: [u8;7],
	c: bool, a: bool, p: bool, m: bool, z: bool,
	active: bool, interrupts: bool,
}

//pub use access::Byte;

impl State {
	/// Creates a fresh state with the processor in an active state and all registers reset.
	pub fn new() -> Self {
		Self {
			register: [Wrapping(0);7],
			c: false, a: false, p: false, m: false, z: false,
			active: true, interrupts: false,
			pc: Wrapping(0), sp: Wrapping(0),
		}
	}
}

#[cfg(feature="open")]
impl<H: Harness + ?Sized, C: BorrowMut<H>> Iterator for Machine<H, C> {
	type Item = Result<core::primitive::u8, crate::string::String>;
	fn next(&mut self) -> Option<Self::Item> {
		let result = self.execute();
		match result {
			Ok(Some(cycles)) => Some(Ok(cycles.get())),
			Ok(None) => None,
			Err(e) => Some(Err(e)),
		}
	}
}

#[cfg(not(feature="open"))]
impl<H: Harness + ?Sized, C: BorrowMut<H>> Iterator for Machine<H, C> {
	type Item = core::primitive::u8;
	fn next(&mut self) -> Option<Self::Item> {
		use core::num::NonZeroU8;
		self.execute().map(NonZeroU8::get)
	}
}