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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#[cfg(feature = "serialize")]
use serde::{Deserialize, Serialize};
pub mod bit {
pub const CARRY: u8 = 0;
pub const ZERO: u8 = 1;
pub const INTERRUPT_DISABLE: u8 = 2;
pub const DECIMAL: u8 = 3;
pub const BRK: u8 = 4;
pub const EXPANSION: u8 = 5;
pub const OVERFLOW: u8 = 6;
pub const NEGATIVE: u8 = 7;
}
pub mod flag {
use super::bit;
pub const CARRY: u8 = 1 << bit::CARRY;
pub const ZERO: u8 = 1 << bit::ZERO;
pub const INTERRUPT_DISABLE: u8 = 1 << bit::INTERRUPT_DISABLE;
pub const DECIMAL: u8 = 1 << bit::DECIMAL;
pub const BRK: u8 = 1 << bit::BRK;
pub const EXPANSION: u8 = 1 << bit::EXPANSION;
pub const OVERFLOW: u8 = 1 << bit::OVERFLOW;
pub const NEGATIVE: u8 = 1 << bit::NEGATIVE;
}
const MASK: u8 = !(flag::BRK | flag::EXPANSION);
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
#[derive(Clone)]
pub struct Register {
raw: u8,
}
impl Register {
pub fn new() -> Self {
Self {
raw: flag::INTERRUPT_DISABLE,
}
}
pub fn masked_with_brk_and_expansion(&self) -> u8 {
self.raw | flag::BRK | flag::EXPANSION
}
pub fn set(&mut self, value: u8) {
self.raw = value & MASK;
}
pub fn set_carry(&mut self) {
self.raw |= flag::CARRY;
}
pub fn clear_carry(&mut self) {
self.raw &= !flag::CARRY;
}
pub fn set_carry_to(&mut self, value: bool) {
self.raw = ((value as u8) << bit::CARRY) | (self.raw & !flag::CARRY);
}
pub fn is_carry(&self) -> bool {
self.raw & flag::CARRY != 0
}
pub fn carry_value(&self) -> u8 {
(self.raw & flag::CARRY) >> bit::CARRY
}
pub fn set_decimal(&mut self) {
self.raw |= flag::DECIMAL;
}
pub fn clear_decimal(&mut self) {
self.raw &= !flag::DECIMAL;
}
pub fn is_decimal(&self) -> bool {
self.raw & flag::DECIMAL != 0
}
pub fn set_zero_from_value(&mut self, value: u8) {
self.raw = (((value == 0) as u8) << bit::ZERO) | (self.raw & !flag::ZERO);
}
pub fn is_zero(&self) -> bool {
self.raw & flag::ZERO != 0
}
pub fn clear_overflow(&mut self) {
self.raw &= !flag::OVERFLOW;
}
pub fn is_overflow(&self) -> bool {
self.raw & flag::OVERFLOW != 0
}
pub fn set_overflow_to(&mut self, value: bool) {
self.raw = ((value as u8) << bit::OVERFLOW) | (self.raw & !flag::OVERFLOW);
}
pub fn clear_negative(&mut self) {
self.raw &= !flag::NEGATIVE;
}
pub fn is_negative(&self) -> bool {
self.raw & flag::NEGATIVE != 0
}
pub fn set_negative_from_value(&mut self, value: u8) {
self.raw = (value & flag::NEGATIVE) | (self.raw & !flag::NEGATIVE);
}
pub fn set_interrupt_disable(&mut self) {
self.raw |= flag::INTERRUPT_DISABLE;
}
pub fn clear_interrupt_disable(&mut self) {
self.raw &= !flag::INTERRUPT_DISABLE;
}
pub fn is_interrupt_disable(&self) -> bool {
self.raw & flag::INTERRUPT_DISABLE != 0
}
}
use std::fmt;
impl fmt::Debug for Register {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"[N={:?},V={:?},D={:?},I:{:?},Z:{:?},C:{:?}]",
self.is_negative() as u8,
self.is_overflow() as u8,
self.is_decimal() as u8,
self.is_interrupt_disable() as u8,
self.is_zero() as u8,
self.is_carry() as u8,
)
}
}