@tmustier/pi-nes 0.2.4 → 0.2.5

package/extensions/nes/native/nes-core/vendor/nes_rust/src/register.rs

@@ -0,0 +1,560 @@
+pub struct Register<T> {
+	data: T
+}
+
+// @TODO: Combine Register<u8> with Register<u16>
+
+impl Register<u8> {
+	pub fn new() -> Register<u8> {
+		Register{ data: 0 }
+	}
+
+	pub fn get_width(&self) -> u8 {
+		8
+	}
+
+	pub fn load(&self) -> u8 {
+		self.data
+	}
+
+	pub fn load_bit(&self, pos: u8) -> u8 {
+		(self.data >> pos) & 1
+	}
+
+	pub fn load_bits(&self, offset: u8, width: u8) -> u8 {
+		(self.data >> offset) & ((1 << width) - 1)
+	}
+
+	pub fn store(&mut self, value: u8) {
+		self.data = value;
+	}
+
+	pub fn store_bit(&mut self, pos: u8, value: u8) {
+		self.data = self.data & !(1 << pos) | ((value & 1) << pos);
+	}
+
+	pub fn store_bits(&mut self, offset: u8, width: u8, value: u8) {
+		let mask = (1 << width) - 1;
+		self.data = self.data & !(mask << offset) | ((value & mask) << offset);
+	}
+
+	pub fn clear(&mut self) {
+		self.data = 0;
+	}
+
+	pub fn set_bit(&mut self, pos: u8) {
+		self.store_bit(pos, 1);
+	}
+
+	pub fn clear_bit(&mut self, pos: u8) {
+		self.store_bit(pos, 0);
+	}
+
+	pub fn is_bit_set(&self, pos: u8) -> bool {
+		self.load_bit(pos) == 1
+	}
+
+	pub fn increment(&mut self) {
+		self.add(1);
+	}
+
+	pub fn increment_by_2(&mut self) {
+		self.add(2);
+	}
+
+	pub fn add(&mut self, value: u8) {
+		self.data = self.data.wrapping_add(value);
+	}
+
+	pub fn decrement(&mut self) {
+		self.sub(1);
+	}
+
+	pub fn decrement_by_2(&mut self) {
+		self.sub(2);
+	}
+
+	pub fn sub(&mut self, value: u8) {
+		self.data = self.data.wrapping_sub(value);
+	}
+
+	pub fn shift(&mut self, value: u8) -> u8 {
+		let carry = self.load_bit(self.get_width() - 1);
+		self.data = (self.data << 1) | (value & 1);
+		carry
+	}
+
+	pub fn dump(&self) -> String {
+		format!("0x{:02x}", self.data)
+	}
+}
+
+impl Register<u16> {
+	pub fn new() -> Register<u16> {
+		Register{ data: 0 }
+	}
+
+	pub fn get_width(&self) -> u8 {
+		16
+	}
+
+	pub fn load(&self) -> u16 {
+		self.data
+	}
+
+	pub fn load_bit(&self, pos: u8) -> u8 {
+		((self.data >> pos) & 1) as u8
+	}
+
+	pub fn load_bits(&self, offset: u8, width: u8) -> u16 {
+		(self.data >> offset) & ((1 << width) - 1)
+	}
+
+	pub fn store(&mut self, value: u16) {
+		self.data = value;
+	}
+
+	pub fn store_bit(&mut self, pos: u8, value: u8) {
+		self.data = self.data & !(1 << pos) | ((value as u16 & 1) << pos);
+	}
+
+	pub fn store_bits(&mut self, offset: u8, width: u8, value: u16) {
+		let mask = (1 << width) - 1;
+		self.data = self.data & !(mask << offset) | ((value & mask) << offset);
+	}
+
+	pub fn clear(&mut self) {
+		self.data = 0;
+	}
+
+	pub fn set_bit(&mut self, pos: u8) {
+		self.store_bit(pos, 1);
+	}
+
+	pub fn clear_bit(&mut self, pos: u8) {
+		self.store_bit(pos, 0);
+	}
+
+	pub fn is_bit_set(&self, pos: u8) -> bool {
+		self.load_bit(pos) == 1
+	}
+
+	pub fn increment(&mut self) {
+		self.add(1);
+	}
+
+	pub fn increment_by_2(&mut self) {
+		self.add(2);
+	}
+
+	pub fn add(&mut self, value: u16) {
+		self.data = self.data.wrapping_add(value);
+	}
+
+	pub fn decrement(&mut self) {
+		self.sub(1);
+	}
+
+	pub fn decrement_by_2(&mut self) {
+		self.sub(2);
+	}
+
+	pub fn sub(&mut self, value: u16) {
+		self.data = self.data.wrapping_sub(value);
+	}
+
+	pub fn shift(&mut self, value: u8) -> u8 {
+		let carry = self.load_bit(self.get_width() - 1);
+		self.data = (self.data << 1) | (value as u16 & 1);
+		carry
+	}
+
+	pub fn store_higher_byte(&mut self, value: u8) {
+		self.data &= 0x00ff;
+		self.data |= (value as u16) << 8;
+	}
+
+	pub fn store_lower_byte(&mut self, value: u8) {
+		self.data &= 0xff00;
+		self.data |= value as u16;
+	}
+
+	pub fn dump(&self) -> String {
+		format!("0x{:04x}", self.data)
+	}
+}
+
+#[cfg(test)]
+mod tests_register_u8 {
+	use super::*;
+
+	#[test]
+	fn initial_value() {
+		let r = Register::<u8>::new();
+		assert_eq!(0, r.data);
+	}
+
+	#[test]
+	fn get_width() {
+		let r = Register::<u8>::new();
+		assert_eq!(8, r.get_width());
+	}
+
+	#[test]
+	fn load() {
+		let r = Register::<u8>::new();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn load_bit() {
+		let mut r = Register::<u8>::new();
+		r.store(2);
+		assert_eq!(1, r.load_bit(1));
+	}
+
+	#[test]
+	fn load_bits() {
+		let mut r = Register::<u8>::new();
+		r.store(2);
+		assert_eq!(1, r.load_bits(1, 2));
+	}
+
+	#[test]
+	fn store() {
+		let mut r = Register::<u8>::new();
+		r.store(0xFF);
+		assert_eq!(0xFF, r.load());
+		r.store(0);
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn store_bit() {
+		let mut r = Register::<u8>::new();
+		r.store_bit(1, 1);
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		r.store_bit(1, 0);
+		assert_eq!(0xFD, r.load());
+	}
+
+	#[test]
+	fn store_bits() {
+		let mut r = Register::<u8>::new();
+		r.store_bits(1, 2, 3);
+		assert_eq!(6, r.load());
+		r.store(0xFF);
+		r.store_bits(1, 2, 0);
+		assert_eq!(0xF9, r.load());
+	}
+
+	#[test]
+	fn clear() {
+		let mut r = Register::<u8>::new();
+		r.store(0xFF);
+		r.clear();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn set_bit() {
+		let mut r = Register::<u8>::new();
+		r.set_bit(1);
+		assert_eq!(2, r.load());
+	}
+
+	#[test]
+	fn clear_bit() {
+		let mut r = Register::<u8>::new();
+		r.store(0xFF);
+		r.clear_bit(1);
+		assert_eq!(0xFD, r.load());
+	}
+
+	#[test]
+	fn is_bit_set() {
+		let mut r = Register::<u8>::new();
+		assert_eq!(false, r.is_bit_set(1));
+		r.set_bit(1);
+		assert_eq!(true, r.is_bit_set(1));
+	}
+
+	#[test]
+	fn increment() {
+		let mut r = Register::<u8>::new();
+		r.increment();
+		assert_eq!(1, r.load());
+		r.store(0xFF);
+		r.increment();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn increment_by_2() {
+		let mut r = Register::<u8>::new();
+		r.increment_by_2();
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		r.increment_by_2();
+		assert_eq!(1, r.load());
+	}
+
+	#[test]
+	fn add() {
+		let mut r = Register::<u8>::new();
+		r.add(3);
+		assert_eq!(3, r.load());
+		r.store(0xFF);
+		r.add(3);
+		assert_eq!(2, r.load());
+	}
+
+	#[test]
+	fn decrement() {
+		let mut r = Register::<u8>::new();
+		r.decrement();
+		assert_eq!(0xFF, r.load());
+		r.decrement();
+		assert_eq!(0xFE, r.load());
+	}
+
+	#[test]
+	fn decrement_by_2() {
+		let mut r = Register::<u8>::new();
+		r.decrement_by_2();
+		assert_eq!(0xFE, r.load());
+		r.decrement_by_2();
+		assert_eq!(0xFC, r.load());
+	}
+
+	#[test]
+	fn sub() {
+		let mut r = Register::<u8>::new();
+		r.sub(3);
+		assert_eq!(0xFD, r.load());
+		r.sub(3);
+		assert_eq!(0xFA, r.load());
+	}
+
+	#[test]
+	fn shift() {
+		let mut r = Register::<u8>::new();
+		assert_eq!(0, r.shift(1));
+		assert_eq!(1, r.load());
+		assert_eq!(0, r.shift(0));
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		assert_eq!(1, r.shift(1));
+		assert_eq!(0xFF, r.load());
+		assert_eq!(1, r.shift(0));
+		assert_eq!(0xFE, r.load());
+	}
+
+	#[test]
+	fn dump() {
+		let mut r = Register::<u8>::new();
+		assert_eq!("0x00", r.dump());
+		r.store(0xFF);
+		assert_eq!("0xff", r.dump());
+		r.store(0x8A);
+		assert_eq!("0x8a", r.dump());
+	}
+}
+
+
+#[cfg(test)]
+mod tests_register_u16 {
+	use super::*;
+
+	#[test]
+	fn initial_value() {
+		let r = Register::<u16>::new();
+		assert_eq!(0, r.data);
+	}
+
+	#[test]
+	fn get_width() {
+		let r = Register::<u16>::new();
+		assert_eq!(16, r.get_width());
+	}
+
+	#[test]
+	fn load() {
+		let r = Register::<u16>::new();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn load_bit() {
+		let mut r = Register::<u16>::new();
+		r.store(2);
+		assert_eq!(1, r.load_bit(1));
+	}
+
+	#[test]
+	fn load_bits() {
+		let mut r = Register::<u16>::new();
+		r.store(2);
+		assert_eq!(1, r.load_bits(1, 2));
+	}
+
+	#[test]
+	fn store() {
+		let mut r = Register::<u16>::new();
+		r.store(0xFF);
+		assert_eq!(0xFF, r.load());
+		r.store(0);
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn store_bit() {
+		let mut r = Register::<u16>::new();
+		r.store_bit(1, 1);
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		r.store_bit(1, 0);
+		assert_eq!(0xFD, r.load());
+	}
+
+	#[test]
+	fn store_bits() {
+		let mut r = Register::<u16>::new();
+		r.store_bits(1, 2, 3);
+		assert_eq!(6, r.load());
+		r.store(0xFF);
+		r.store_bits(1, 2, 0);
+		assert_eq!(0xF9, r.load());
+	}
+
+	#[test]
+	fn clear() {
+		let mut r = Register::<u16>::new();
+		r.store(0xFF);
+		r.clear();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn set_bit() {
+		let mut r = Register::<u16>::new();
+		r.set_bit(1);
+		assert_eq!(2, r.load());
+	}
+
+	#[test]
+	fn clear_bit() {
+		let mut r = Register::<u16>::new();
+		r.store(0xFF);
+		r.clear_bit(1);
+		assert_eq!(0xFD, r.load());
+	}
+
+	#[test]
+	fn is_bit_set() {
+		let mut r = Register::<u16>::new();
+		assert_eq!(false, r.is_bit_set(1));
+		r.set_bit(1);
+		assert_eq!(true, r.is_bit_set(1));
+	}
+
+	#[test]
+	fn increment() {
+		let mut r = Register::<u16>::new();
+		r.increment();
+		assert_eq!(1, r.load());
+		r.store(0xFF);
+		r.increment();
+		assert_eq!(0x100, r.load());
+		r.store(0xFFFF);
+		r.increment();
+		assert_eq!(0, r.load());
+	}
+
+	#[test]
+	fn increment_by_2() {
+		let mut r = Register::<u16>::new();
+		r.increment_by_2();
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		r.increment_by_2();
+		assert_eq!(0x101, r.load());
+		r.store(0xFFFF);
+		r.increment_by_2();
+		assert_eq!(1, r.load());
+	}
+
+	#[test]
+	fn add() {
+		let mut r = Register::<u16>::new();
+		r.add(3);
+		assert_eq!(3, r.load());
+		r.store(0xFF);
+		r.add(3);
+		assert_eq!(0x102, r.load());
+		r.store(0xFFFF);
+		r.add(3);
+		assert_eq!(2, r.load());
+	}
+
+	#[test]
+	fn decrement() {
+		let mut r = Register::<u16>::new();
+		r.decrement();
+		assert_eq!(0xFFFF, r.load());
+		r.decrement();
+		assert_eq!(0xFFFE, r.load());
+	}
+
+	#[test]
+	fn decrement_by_2() {
+		let mut r = Register::<u16>::new();
+		r.decrement_by_2();
+		assert_eq!(0xFFFE, r.load());
+		r.decrement_by_2();
+		assert_eq!(0xFFFC, r.load());
+	}
+
+	#[test]
+	fn sub() {
+		let mut r = Register::<u16>::new();
+		r.sub(3);
+		assert_eq!(0xFFFD, r.load());
+		r.sub(3);
+		assert_eq!(0xFFFA, r.load());
+	}
+
+	#[test]
+	fn shift() {
+		let mut r = Register::<u16>::new();
+		assert_eq!(0, r.shift(1));
+		assert_eq!(1, r.load());
+		assert_eq!(0, r.shift(0));
+		assert_eq!(2, r.load());
+		r.store(0xFF);
+		assert_eq!(0, r.shift(1));
+		assert_eq!(0x1FF, r.load());
+		assert_eq!(0, r.shift(0));
+		assert_eq!(0x3FE, r.load());
+		r.store(0xFFFF);
+		assert_eq!(1, r.shift(1));
+		assert_eq!(0xFFFF, r.load());
+		assert_eq!(1, r.shift(0));
+		assert_eq!(0xFFFE, r.load());
+	}
+
+	#[test]
+	fn dump() {
+		let mut r = Register::<u16>::new();
+		assert_eq!("0x0000", r.dump());
+		r.store(0xFF);
+		assert_eq!("0x00ff", r.dump());
+		r.store(0x8A);
+		assert_eq!("0x008a", r.dump());
+		r.store(0xFFFF);
+		assert_eq!("0xffff", r.dump());
+		r.store(0xA88A);
+		assert_eq!("0xa88a", r.dump());
+	}
+}