From 28958d0810560dfd3ff289596a173457677289d4 Mon Sep 17 00:00:00 2001 From: Able Date: Tue, 18 Apr 2023 21:41:27 -0500 Subject: [PATCH] restructure --- src/engine/mod.rs | 359 +++++++++++++++++++-------------------------- src/engine/regs.rs | 1 + src/main.rs | 17 ++- 3 files changed, 161 insertions(+), 216 deletions(-) diff --git a/src/engine/mod.rs b/src/engine/mod.rs index 332605f..e1f330f 100644 --- a/src/engine/mod.rs +++ b/src/engine/mod.rs @@ -132,230 +132,87 @@ F5-F9 {:016X} {:016X} {:016X} {:016X} {:016X}", if self.index == self.program.len() { break; } - let op = self.program[self.index]; - println!("OP {} INDEX {}", self.program[self.index], self.index); + let op = (self.program[self.index], self.program[self.index + 1]); + println!("OP {} INDEX {}", op.0, self.index); match op { - NOP => self.index += 1, - ADD => { - print!("Add"); + (0, _) => { + println!("NO OP"); self.index += 1; - let mut lhs: Vec = vec![]; - let mut rhs: Vec = vec![]; - let mut lhs_signed = false; - let mut rhs_signed = false; - - match self.program[self.index] { - CONST_U8 => { - self.index += 1; - lhs.push(self.program[self.index]); - print!(" constant {:?}", lhs[0]); - lhs_signed = false; - self.index += 1; - } - CONST_U64 => { - self.index += 1; - lhs.push(self.program[self.index]); - self.index += 1; - lhs.push(self.program[self.index]); - self.index += 1; - lhs.push(self.program[self.index]); - self.index += 1; - lhs.push(self.program[self.index]); - - lhs_signed = false; - self.index += 1; - } - 0xA0..=0xC9 => { - println!("TRACE: 8 bit lhs"); - } - 0xD0..=0xFF => { - println!("TRACE: 64 bit lhs"); - } - op => return Err(InvalidOpcode(op)), - } - - match self.program[self.index] { - CONST_U8 => { - self.index += 1; - rhs.push(self.program[self.index]); - rhs_signed = false; - print!(" constant {:?}", rhs[0]); - self.index += 1; - } - - CONST_U64 => { - self.index += 1; - rhs.push(self.program[self.index]); - self.index += 1; - rhs.push(self.program[self.index]); - self.index += 1; - rhs.push(self.program[self.index]); - self.index += 1; - rhs.push(self.program[self.index]); - - print!(" constant {:?}", rhs[0]); - rhs_signed = false; - self.index += 1; - } - 0xA0..=0xC9 => { - println!("TRACE: 8 bit rhs"); - } - 0xD0..=0xFF => { - println!("TRACE: 64 bit rhs"); - } - - _ => { - panic!() - } - } - match self.program[self.index] { - 0xA0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 1 { - panic!("RHS is not an 8 bit number") - } - println!(" store in A0"); - - let sum = lhs[0] + rhs[0]; - self.registers.a0 = sum; - self.index += 1; - } - 0xB0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 1 { - panic!("RHS is not an 8 bit number") - } - println!(" store in B0"); - let sum = lhs[0] + rhs[0]; - self.registers.b0 = sum; - self.index += 1; - } - 0xC0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 1 { - panic!("RHS is not an 8 bit number") - } - println!(" store in C0"); - let sum = lhs[0] + rhs[0]; - self.registers.c8 = sum; - self.index += 1; - } - 0xD0 => { - if lhs.len() > 4 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 4 { - panic!("RHS is not an 8 bit number") - } - println!(" store in D0"); - let lhs: u64 = Into::::into(lhs[3]) << 60; - println!("{}", lhs); - println!("{}", 2); - // let rhs: u64 = (rhs[4] << 16).into(); - let rhs: u64 = 0; - let sum = lhs + rhs; - self.registers.d0 = sum; - self.index += 1; - } - - op => { - println!("{}", op) - } - } } - SUB => { - print!("Sub"); - self.index += 1; - let mut lhs: Vec = vec![]; - let mut rhs: Vec = vec![]; - let mut lhs_signed = false; - let mut rhs_signed = false; + // Add a 8 bit num + (1, 1) => { + let lhs = self.program[self.index + 2]; + println!("LHS 8BIT {}", lhs); + let rhs = self.program[self.index + 3]; + println!("RHS 8BIT {}", rhs); - match self.program[self.index] { - 0xA0 => { - lhs.push(self.registers.a8); - lhs_signed = false; - print!(" constant {:?}", self.registers.a8); - self.index += 1; - } - 0xB0 => { - lhs.push(self.registers.b8); - lhs_signed = false; - print!(" constant {:?}", self.registers.b8); - self.index += 1; - } - CONST_U8 => { - self.index += 1; - lhs.push(self.program[self.index]); - print!(" constant {:?}", lhs[0]); - lhs_signed = false; - self.index += 1; - } - op => return Err(InvalidOpcode(op)), - } + let ret = lhs + rhs; + let reg = self.program[self.index + 4]; - match self.program[self.index] { - 0xB0 => { - rhs.push(self.registers.b8); - rhs_signed = false; - print!(" constant {:?}", self.registers.b8); - self.index += 1; + match reg { + 0xA0..=0xC9 => { + self.set_register_8(reg, ret); + } + 0xD0..=0xF9 => { + panic!("Register oversized") } _ => { - panic!() + panic!("Not a register.") } } - match self.program[self.index] { - 0xA0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - println!(" store in A8"); - let sum = lhs[0] - rhs[0]; - self.registers.a8 = sum; - self.index += 1; - } - 0xB0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 1 { - panic!("RHS is not an 8 bit number") - } - println!(" store in B8"); - let sum = lhs[0] - rhs[0]; - self.registers.b8 = sum; - self.index += 1; - } - 0xC0 => { - if lhs.len() > 1 { - panic!("LHS is not an 8 bit number") - } - if rhs.len() > 1 { - panic!("RHS is not an 8 bit number") - } - println!(" store in B8"); - let sum = lhs[0] - rhs[0]; - self.registers.c8 = sum; - self.index += 1; - } - _ => { - panic!() - } - } + self.index += 5; } - op => { - println!("INVALID OPCODE {}", op); + // Add a 64 bit num + (1, 2) => { + let mut lhs_array = [0; 8]; + let mut rhs_array = [0; 8]; + + for (index, byte) in self.program[self.index + 2..self.index + 10] + .into_iter() + .enumerate() + { + lhs_array[index] = *byte; + } + let lhs = u64::from_be_bytes(lhs_array); + println!("LHS 64BIT {}", lhs); + + for (index, byte) in self.program[self.index + 10..self.index + 18] + .into_iter() + .enumerate() + { + rhs_array[index] = *byte; + } + + let rhs = u64::from_be_bytes(rhs_array); + + println!("RHS 64BIT {}", rhs); + + let ret = lhs + rhs; + + let reg = self.program[self.index + 18]; + println!("Store {} in {:02X}", ret, reg); + + match reg { + 0xA0..=0xC9 => { + panic!("Register undersized") + } + 0xD0..=0xF9 => { + self.set_register_64(reg, ret); + } + _ => { + panic!("Not a register.") + } + } + + self.index += 19; + } + op_pair => { + println!("OP Pair {}", op_pair.0); self.index += 1; } } + // Finish step if self.timer_callback.is_some() { @@ -367,4 +224,86 @@ F5-F9 {:016X} {:016X} {:016X} {:016X} {:016X}", } Ok(Halted) } + + pub fn set_register_8(&mut self, register: u8, value: u8) { + match register { + 0xA0 => self.registers.a0 = value, + 0xA1 => self.registers.a1 = value, + 0xA2 => self.registers.a2 = value, + 0xA3 => self.registers.a3 = value, + 0xA4 => self.registers.a4 = value, + 0xA5 => self.registers.a5 = value, + 0xA6 => self.registers.a6 = value, + 0xA7 => self.registers.a7 = value, + 0xA8 => self.registers.a8 = value, + 0xA9 => self.registers.a9 = value, + // + 0xB0 => self.registers.b0 = value, + 0xB1 => self.registers.b1 = value, + 0xB2 => self.registers.b2 = value, + 0xB3 => self.registers.b3 = value, + 0xB4 => self.registers.b4 = value, + 0xB5 => self.registers.b5 = value, + 0xB6 => self.registers.b6 = value, + 0xB7 => self.registers.b7 = value, + 0xB8 => self.registers.b8 = value, + 0xB9 => self.registers.b9 = value, + // + 0xC0 => self.registers.c0 = value, + 0xC1 => self.registers.c1 = value, + 0xC2 => self.registers.c2 = value, + 0xC3 => self.registers.c3 = value, + 0xC4 => self.registers.c4 = value, + 0xC5 => self.registers.c5 = value, + 0xC6 => self.registers.c6 = value, + 0xC7 => self.registers.c7 = value, + 0xC8 => self.registers.c8 = value, + 0xC9 => self.registers.c9 = value, + + _ => { + panic!("Unlikely you are here if everyone behaved.\nThis register is not 8 bit") + } + } + } + pub fn set_register_64(&mut self, register: u8, value: u64) { + match register { + 0xD0 => self.registers.d0 = value, + 0xD1 => self.registers.d1 = value, + 0xD2 => self.registers.d2 = value, + 0xD3 => self.registers.d3 = value, + 0xD4 => self.registers.d4 = value, + 0xD5 => self.registers.d5 = value, + 0xD6 => self.registers.d6 = value, + 0xD7 => self.registers.d7 = value, + 0xD8 => self.registers.d8 = value, + 0xD9 => self.registers.d9 = value, + // + 0xE0 => self.registers.f0 = value, + 0xE1 => self.registers.f1 = value, + 0xE2 => self.registers.f2 = value, + 0xE3 => self.registers.f3 = value, + 0xE4 => self.registers.f4 = value, + 0xE5 => self.registers.f5 = value, + 0xE6 => self.registers.f6 = value, + 0xE7 => self.registers.f7 = value, + 0xE8 => self.registers.f8 = value, + 0xE9 => self.registers.f9 = value, + + // + 0xF0 => self.registers.f0 = value, + 0xF1 => self.registers.f1 = value, + 0xF2 => self.registers.f2 = value, + 0xF3 => self.registers.f3 = value, + 0xF4 => self.registers.f4 = value, + 0xF5 => self.registers.f5 = value, + 0xF6 => self.registers.f6 = value, + 0xF7 => self.registers.f7 = value, + 0xF8 => self.registers.f8 = value, + 0xF9 => self.registers.f9 = value, + + _ => { + panic!("Unlikely you are here if everyone behaved.\nThis register is not 64 bit") + } + } + } } diff --git a/src/engine/regs.rs b/src/engine/regs.rs index 7d4710a..27fc413 100644 --- a/src/engine/regs.rs +++ b/src/engine/regs.rs @@ -11,6 +11,7 @@ pub struct Registers{ pub a8: u8, pub b8: u8, pub c8: u8, pub d8: u64, pub e8: u64, pub f8: u64, pub a9: u8, pub b9: u8, pub c9: u8, pub d9: u64, pub e9: u64, pub f9: u64, } + impl Registers { #[rustfmt::skip] pub fn new() -> Self{ diff --git a/src/main.rs b/src/main.rs index ca98575..b116ffc 100644 --- a/src/main.rs +++ b/src/main.rs @@ -4,17 +4,22 @@ use holey_bytes::RuntimeErrors; use holey_bytes::{bytecode::types::CONST_U8, engine::Engine}; fn main() -> Result<(), RuntimeErrors> { + use holey_bytes::bytecode::ops::MathTypes::*; #[rustfmt::skip] let prog: Vec = vec![ - NOP as u8, - ADD as u8, CONST_U8, 1, CONST_U8, 20, 0xA0, - ADD as u8, CONST_U8, 1, CONST_U8, 0, 0xB0, - ADD as u8, CONST_U64, 0, 0, 0, 2, CONST_U64, 0, 0, 0, 2, 0xD0, - // SUB, CONST_U8, 4, CONST_U8, 1, 0xC8, + NOP as u8, NOP as u8, + ADD as u8, EightBit as u8, 100, 20, 0xA7, + ADD as u8, + EightBit as u8, 1, 0, 0xB0, + ADD as u8, + SixtyFourBit as u8, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2, 0xD0 + ]; let mut eng = Engine::new(prog); // eng.timer_callback = Some(time); eng.run()?; - // eng.dump(); + eng.dump(); Ok(()) }