IntoTheNight
/
holey-bytes
forked from AbleOS/holey-bytes
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
holey-bytes/src/engine/mod.rs

371 lines
13 KiB
Rust
Raw Blame History

pub mod call_stack;
pub mod config;
pub mod regs;
use crate::bytecode::ops::*;
use crate::bytecode::types::*;
use crate::HaltStatus;
use crate::Page;
use crate::RuntimeErrors;
use config::EngineConfig;
use regs::Registers;
use self::call_stack::CallStack;
pub struct Engine {
pub index: usize,
program: Vec<u8>,
registers: Registers,
config: EngineConfig,
/// BUG: This DOES NOT account for overflowing
last_timer_count: u32,
timer_callback: Option<fn() -> u32>,
memory: Vec<Page>,
call_stack: CallStack,
}
impl Engine {
pub fn new(program: Vec<u8>) -> Self {
Self {
index: 0,
program,
registers: Registers::new(),
config: EngineConfig::default(),
last_timer_count: 0,
timer_callback: None,
memory: vec![],
call_stack: vec![],
}
}
pub fn dump(&self) {
println!("Registers");
println!(
"A {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
self.registers.a0,
self.registers.a1,
self.registers.a2,
self.registers.a3,
self.registers.a4,
self.registers.a5,
self.registers.a6,
self.registers.a7,
self.registers.a8,
self.registers.a9,
);
println!(
"B {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
self.registers.b0,
self.registers.b1,
self.registers.b2,
self.registers.b3,
self.registers.b4,
self.registers.b5,
self.registers.b6,
self.registers.b7,
self.registers.b8,
self.registers.b9,
);
println!(
"C {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X} {:02X}",
self.registers.c0,
self.registers.c1,
self.registers.c2,
self.registers.c3,
self.registers.c4,
self.registers.c5,
self.registers.c6,
self.registers.c7,
self.registers.c8,
self.registers.c9,
);
println!(
"D0-D4 {:016X} {:016X} {:016X} {:016X} {:016X}
D5-D9 {:016X} {:016X} {:016X} {:016X} {:016X}",
self.registers.d0,
self.registers.d1,
self.registers.d2,
self.registers.d3,
self.registers.d4,
self.registers.d5,
self.registers.d6,
self.registers.d7,
self.registers.d8,
self.registers.d9,
);
println!(
"E0-E4 {:016X} {:016X} {:016X} {:016X} {:016X}
E5-E9 {:016X} {:016X} {:016X} {:016X} {:016X}",
self.registers.e0,
self.registers.e1,
self.registers.e2,
self.registers.e3,
self.registers.e4,
self.registers.e5,
self.registers.e6,
self.registers.e7,
self.registers.e8,
self.registers.e9,
);
println!(
"F0-F4 {:016X} {:016X} {:016X} {:016X} {:016X}
F5-F9 {:016X} {:016X} {:016X} {:016X} {:016X}",
self.registers.f0,
self.registers.f1,
self.registers.f2,
self.registers.f3,
self.registers.f4,
self.registers.f5,
self.registers.f6,
self.registers.f7,
self.registers.f8,
self.registers.f9,
);
}
pub fn run(&mut self) -> Result<HaltStatus, RuntimeErrors> {
use HaltStatus::*;
use RuntimeErrors::*;
loop {
// Break out of the loop
if self.index == self.program.len() {
break;
}
let op = self.program[self.index];
println!("OP {} INDEX {}", self.program[self.index], self.index);
match op {
NOP => self.index += 1,
ADD => {
print!("Add");
self.index += 1;
let mut lhs: Vec<u8> = vec![];
let mut rhs: Vec<u8> = 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::<u64>::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<u8> = vec![];
let mut rhs: Vec<u8> = vec![];
let mut lhs_signed = false;
let mut rhs_signed = false;
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)),
}
match self.program[self.index] {
0xB0 => {
rhs.push(self.registers.b8);
rhs_signed = false;
print!(" constant {:?}", self.registers.b8);
self.index += 1;
}
_ => {
panic!()
}
}
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!()
}
}
}
op => {
println!("INVALID OPCODE {}", op);
self.index += 1;
}
}
// Finish step
if self.timer_callback.is_some() {
let ret = self.timer_callback.unwrap()();
if (ret - self.last_timer_count) >= self.config.quantum {
return Ok(Running);
}
}
}
Ok(Halted)
}
}
Reference in New Issue View Git Blame Copy Permalink