141 lines
2.4 KiB
Rust
141 lines
2.4 KiB
Rust
#![allow(dead_code)]
|
|
|
|
mod mem;
|
|
use core::panic;
|
|
// use std::env;
|
|
// use std::fs;
|
|
// use std::io;
|
|
// use std::io::Read;
|
|
use std::u16;
|
|
|
|
use mem::Memory;
|
|
|
|
struct Registers {
|
|
r0: u16,
|
|
r1: u16,
|
|
r2: u16,
|
|
r3: u16,
|
|
r4: u16,
|
|
r5: u16,
|
|
r6: u16,
|
|
r7: u16,
|
|
pc: u16,
|
|
cond: u16,
|
|
}
|
|
|
|
enum ConditionFlags {
|
|
// condition flags can only be set as nzp with a 1 in each position
|
|
POS = 1 << 0,
|
|
ZERO = 1 << 1,
|
|
NEG = 1 << 2,
|
|
}
|
|
|
|
impl Registers {
|
|
fn new() -> Registers {
|
|
Registers {
|
|
r0: 0,
|
|
r1: 0,
|
|
r2: 0,
|
|
r3: 0,
|
|
r4: 0,
|
|
r5: 0,
|
|
r6: 0,
|
|
r7: 0,
|
|
pc: 0x300,
|
|
cond: 0,
|
|
}
|
|
}
|
|
|
|
// s/o dogeystamp for this cool register return logic
|
|
// most other vms just updated it with a &mut self
|
|
|
|
fn return_register(&mut self, num: u16) -> &mut u16 {
|
|
match num {
|
|
0 => &mut self.r0,
|
|
1 => &mut self.r1,
|
|
2 => &mut self.r2,
|
|
3 => &mut self.r3,
|
|
4 => &mut self.r4,
|
|
5 => &mut self.r5,
|
|
6 => &mut self.r6,
|
|
7 => &mut self.r7,
|
|
8 => &mut self.pc,
|
|
9 => &mut self.cond,
|
|
_ => panic!("not a register!"),
|
|
}
|
|
}
|
|
|
|
fn get_register(&mut self, num: u16) -> u16 {
|
|
*self.return_register(num)
|
|
}
|
|
|
|
fn set_registers(&mut self, num : u16, value: u16) {
|
|
*self.return_register(num) = value;
|
|
}
|
|
|
|
fn update_cond(&mut self, num : u16) {
|
|
if *self.return_register(num) > 0 {
|
|
self.cond = ConditionFlags::POS as u16;
|
|
} else if *self.return_register(num) == 0 {
|
|
self.cond = ConditionFlags::ZERO as u16;
|
|
} else {
|
|
self.cond = ConditionFlags::NEG as u16
|
|
}
|
|
}
|
|
|
|
fn update_reg_and_cond(&mut self, num : u16, value: u16) {
|
|
self.set_registers(num, value);
|
|
self.update_cond(num);
|
|
}
|
|
}
|
|
|
|
enum State {
|
|
Stopped = 0,
|
|
Running,
|
|
}
|
|
|
|
struct VM {
|
|
memory: Memory,
|
|
registers: Registers,
|
|
state: State,
|
|
}
|
|
|
|
impl VM {
|
|
fn new() -> VM {
|
|
VM{
|
|
memory: Memory::new(),
|
|
registers: Registers::new(),
|
|
state: State::Stopped,
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// let args: Vec<String> = env::args().collect();
|
|
// let path = args.get(1).expect("enter a file please!");
|
|
// let file = fs::File::open(path).expect("couldnt open file");
|
|
// let mut reader = io::BufReader::new(file);
|
|
// let mut values = Vec::new();
|
|
// let mut buffer:[u8;2] = [0;2];
|
|
// while reader.read_exact(&mut buffer).is_ok() {
|
|
// let instruction = u16::from_be_bytes(buffer);
|
|
// values.push(instruction);
|
|
// }
|
|
// println!("data: {:?}\n", values);
|
|
// for data in values{
|
|
// println!("hex data: {:#06X}", data);
|
|
// }
|
|
}
|