started on codegen, scaffolding basically done

.cargo/config.toml

@@ -0,0 +1,7 @@
+[build]
+rustc-wrapper = "sccache"
+# Enable to cut unused deps.
+# rustflags = ["-D", "unused-crate-dependencies"]
+
+[future-incompat-report]
+frequency = "always"

.vscode/settings.json

@@ -5,5 +5,7 @@
   "files.eol": "\n",
   "files.insertFinalNewline": true,
   "files.trimFinalNewlines": true,
-  "files.trimTrailingWhitespace": true
+  "files.trimTrailingWhitespace": true,
+  "gitea.owner": "LowLevelDevs",
+  "gitea.repo": "damn_simple_architecture",
 }

Cargo.lock

@@ -424,9 +424,9 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "bit-set"
@@ -539,6 +539,10 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
+[[package]]
+name = "c_compiler"
+version = "0.2.0"
+
 [[package]]
 name = "calloop"
 version = "0.13.0"
@@ -642,6 +646,10 @@ dependencies = [
 name = "common"
 version = "0.2.0"
 
+[[package]]
+name = "compiler"
+version = "0.2.0"
+
 [[package]]
 name = "concurrent-queue"
 version = "2.5.0"
@@ -1091,12 +1099,12 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
-version = "0.3.12"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
+checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1641,9 +1649,9 @@ dependencies = [
 
 [[package]]
 name = "jpeg-decoder"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+checksum = "00810f1d8b74be64b13dbf3db89ac67740615d6c891f0e7b6179326533011a07"
 
 [[package]]
 name = "js-sys"
@@ -1674,9 +1682,9 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
 
 [[package]]
 name = "libc"
-version = "0.2.173"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8cfeafaffdbc32176b64fb251369d52ea9f0a8fbc6f8759edffef7b525d64bb"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "libloading"
@@ -1909,18 +1917,19 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
+checksum = "a973b4e44ce6cad84ce69d797acf9a044532e4184c4f267913d1b546a0727b7a"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
+checksum = "77e878c846a8abae00dd069496dbe8751b16ac1c3d6bd2a7283a938e8228f90d"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2435,9 +2444,9 @@ dependencies = [
 
 [[package]]
 name = "profiling"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"
 
 [[package]]
 name = "quick-xml"
@@ -2495,9 +2504,9 @@ dependencies = [
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "rand"
@@ -2855,9 +2864,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.103"
+version = "2.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4307e30089d6fd6aff212f2da3a1f9e32f3223b1f010fb09b7c95f90f3ca1e8"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3046,9 +3055,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.29"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1ffbcf9c6f6b99d386e7444eb608ba646ae452a36b39737deb9663b610f662"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3987,9 +3996,9 @@ checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
 
 [[package]]
 name = "xcursor"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ef33da6b1660b4ddbfb3aef0ade110c8b8a781a3b6382fa5f2b5b040fd55f61"
+checksum = "635887f4315a33cb714eb059bdbd7c1c92bfa71bc5b9d5115460502f788c2ab5"
 
 [[package]]
 name = "xdg-home"
@@ -4151,18 +4160,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.25"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+checksum = "1039dd0d3c310cf05de012d8a39ff557cb0d23087fd44cad61df08fc31907a2f"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.25"
+version = "0.8.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+checksum = "9ecf5b4cc5364572d7f4c329661bcc82724222973f2cab6f050a4e5c22f75181"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -1,8 +1,17 @@
+cargo-features = ["codegen-backend"]
+
 [workspace]
-members = ["emulator", "common", "assembler", "dsa_editor"]
+members = ["emulator", "common", "assembler", "dsa_editor", "compiler", "c_compiler"]
 resolver = "3"
 
 [workspace.package]
 version = "0.2.0"
 edition = "2024"
 authors = ["zxq5", "nullndvoid"]
+
+[profile.dev]
+codegen-backend = "cranelift"
+panic = "abort" # Cranelift does not support stack unwinds.
+lto = false
+debug = true
+incremental = false # sccache does not support caching incremental crates.

assembler/brainf.bf

@@ -1,34 +1,29 @@
-++++++++++++++++++++++++++++++++++++++++++++		c1v44 : ASCII code of comma
->++++++++++++++++++++++++++++++++			c2v32 : ASCII code of space
->++++++++++++++++					c3v11 : quantity of numbers to be calculated
->							c4v0  : zeroth Fibonacci number (will not be printed)
->+							c5v1  : first Fibonacci number
-<<							c3    : loop counter
-[							block : loop to print (i)th number and calculate next one
->>							c5    : the number to be printed
-
-							block : divide c5 by 10 (preserve c5)
->							c6v0  : service zero
->++++++++++						c7v10 : divisor
-<<							c5    : back to dividend
-[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]			c5v0  : divmod algo; results in 0 n d_n%d n%d n/d
->[<+>-]							c5    : move dividend back to c5 and clear c6
->[-]							c7v0  : clear c7
-
->>							block : c9 can have two digits; divide it by ten again
->++++++++++						c10v10: divisor
-<							c9    : back to dividend
-[->-[>+>>]>[+[-<+>]>+>>]<<<<<]				c9v0  : another divmod algo; results in 0 d_n%d n%d n/d
->[-]							c10v0 : clear c10
->>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]c12v0 : print nonzero n/d (first digit) and clear c12
-<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]] c11v0 : print nonzero n%d (second digit) and clear c11
-
-<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]	c8v0  : print any n%d (last digit) and clear c8
-<<<<<<<.>.                                              c1c2  : print comma and space
-							block : actually calculate next Fibonacci in c6
->>[>>+<<-]						c4v0  : move c4 to c6 (don't need to preserve it)
->[>+<<+>-]						c5v0  : move c5 to c6 and c4 (need to preserve it)
->[<+>-]							c6v0  : move c6 with sum to c5
-<<<-							c3    : decrement loop counter
+++++++++++++++++++++++++++++++++++++++++++++
+>++++++++++++++++++++++++++++++++
+>++++++++++++++++
+>
+>+
+<<
+[
+>>
+>
+>++++++++++
+<<
+[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]
+>[<+>-]
+>[-]
+>>
+>++++++++++
+<
+[->-[>+>>]>[+[-<+>]>+>>]<<<<<]
+>[-]
+>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]
+<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]
+<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]
+<<<<<<<.>.
+>>[>>+<<-]
+>[>+<<+>-]
+>[<+>-]
+<<<-
 ]
-<<++...							c1    : output three dots
+<<++...

assembler/src/assembler/codegen.rs

@@ -11,10 +11,7 @@ pub fn codegen(nodes: Vec<Node>) -> Result<Vec<Instruction>, AssembleError> {
     let mut instructions = vec![];
 
     for node in nodes {
-        instructions.push(
-            build_instruction(&node)
-                .unwrap_or_else(|_| panic!("Failed to build instruction: {node:?}")),
-        );
+        instructions.push(build_instruction(&node)?);
     }
 
     println!("------------------------");

assembler/src/assembler/lexer.rs

@@ -7,12 +7,11 @@ use common::prelude::Register;
 pub fn lexer(mut program: String, module: u64) -> Result<Vec<Token>, AssembleError> {
     let mut tokens = Vec::new();
 
-    program = program.replace(',', "");
     let lines = program.lines();
     let mut literal = String::new();
 
     for line in lines {
-        for token in line.split_whitespace() {
+        for (i, token) in line.split_whitespace().enumerate() {
             if token.starts_with("//") {
                 break;
             }
@@ -23,7 +22,9 @@ pub fn lexer(mut program: String, module: u64) -> Result<Vec<Token>, AssembleErr
 
             if !literal.is_empty() {
                 if !token.starts_with('"') {
+                    if i > 0 {
                         literal.push(' ');
+                    }
                     literal.push_str(token);
                 }
 
@@ -37,6 +38,11 @@ pub fn lexer(mut program: String, module: u64) -> Result<Vec<Token>, AssembleErr
                 continue;
             }
 
+            let token = token.trim_end_matches(',');
+            if token.is_empty() {
+                continue;
+            }
+
             if let Some(token) = parse_register(token)? {
                 tokens.push(token);
             } else if let Some(token) = parse_opcode(token)? {
@@ -59,6 +65,8 @@ pub fn lexer(mut program: String, module: u64) -> Result<Vec<Token>, AssembleErr
         }
     }
 
+    println!("{:#?}", tokens);
+
     Ok(tokens)
 }
 pub fn parse_register(token: &str) -> Result<Option<Token>, AssembleError> {

assembler/src/assembler/macros.rs

@@ -1,7 +1,6 @@
 //! Macros used throughout the assembler
 
 use crate::assembler::model::{Node, Opcode, Symbol, Token};
-
 /// Parse DSA assembly code with optional formatting
 ///
 /// # Examples

assembler/src/assembler/mod.rs

@@ -138,6 +138,11 @@ fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
     create_sections(&mut nodes)?;
     resolve_symbols(&mut nodes)?;
 
+    println!("Generating assembly output...");
+    for n in &nodes {
+        println!("{n}");
+    }
+
     let instructions = codegen(nodes)?;
     Ok(instructions)
 }

assembler/src/assembler/model.rs

@@ -51,19 +51,26 @@ impl fmt::Display for Node {
             .as_ref()
             .map_or_else(String::new, |symbol| format!("{symbol}:\n"));
 
+        let args = self
+            .args()
+            .into_iter()
+            .map(|arg| arg.to_string())
+            .collect::<Vec<_>>()
+            .join(" ");
+
         write!(
             f,
-            "\x1b[93m{} \t\x1b[94m{} \x1b[37m{:?} \x1b[0m",
+            "\x1b[93m{} \t\x1b[94m{} \x1b[37m{} \x1b[0m",
             symbol,
             self.opcode(),
-            self.args()
+            args,
         )
     }
 }
 
 impl fmt::Display for Symbol {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} ( module: {})", self.name, self.module)
+        write!(f, "{} [ID:{}]", self.name, self.module)
     }
 }
 
@@ -174,6 +181,18 @@ pub enum Token {
     Opcode(Opcode),
 }
 
+impl fmt::Display for Token {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Symbol(symbol) => write!(f, "{}", symbol),
+            Self::Register(register) => write!(f, "{}", register),
+            Self::Immediate(immediate) => write!(f, "{}", immediate),
+            Self::StringLit(string_lit) => write!(f, "{}", string_lit),
+            Self::Opcode(opcode) => write!(f, "{}", opcode),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum TokenType {
     Symbol,

assembler/src/assembler/parser.rs

@@ -113,11 +113,10 @@ impl Parser {
                 let dest = expect_type!(self.next()?, Register)?;
 
                 let mut offset = Token::Immediate(0);
-                if let Ok(next) = self.peek_next() {
-                    if expect_type!(next, Immediate).is_ok() {
+                if let Ok(next) = self.peek_next()
+                    && expect_type!(next, Immediate).is_ok() {
                         offset = self.next()?;
                     }
-                }
 
                 args = vec![base, dest, offset];
             }
@@ -125,11 +124,10 @@ impl Parser {
                 let base = expect_type!(self.next()?, Register)?;
                 let dest = expect_type!(self.next()?, Register, Symbol)?;
                 let mut offset = Token::Immediate(0);
-                if let Ok(next) = self.peek_next() {
-                    if expect_type!(next, Immediate).is_ok() {
+                if let Ok(next) = self.peek_next()
+                    && expect_type!(next, Immediate).is_ok() {
                         offset = self.next()?;
                     }
-                }
                 args = vec![base, dest, offset];
             }
 

assembler/src/lib.rs

@@ -13,11 +13,16 @@
 )]
 
 pub mod assembler;
-pub mod brainf;
+pub mod image_builder;
 pub mod tooling;
 mod util;
 
 pub mod prelude {
     pub use crate::assembler::CompilerEngine;
+    pub use crate::image_builder;
+    pub use crate::tooling::brainf;
     pub use crate::tooling::project;
 }
+
+use num_cpus as _;
+use threadpool as _;

assembler/src/main.rs

@@ -1,4 +1,11 @@
-use assembler::{brainf, prelude::*};
+use common as _;
+use num_cpus as _;
+use threadpool as _;
+
+use assembler::{
+    prelude::*,
+    tooling::{brainf, project},
+};
 use std::{fs, io::Write, path::PathBuf};
 
 fn main() {
@@ -16,7 +23,7 @@ fn main() {
 
         let mut file = match fs::File::create("brainf.dsb") {
             Err(e) => {
-                eprintln!("Failed to create output file: {}", e);
+                eprintln!("Failed to create output file: {e}");
                 std::process::exit(1);
             }
             Ok(file) => file,
@@ -24,7 +31,7 @@ fn main() {
 
         for instruction in result {
             if let Err(e) = file.write(&instruction.encode().to_be_bytes()) {
-                eprintln!("Failed to write to output file: {}", e);
+                eprintln!("Failed to write to output file: {e}");
                 std::process::exit(1);
             }
         }
@@ -50,7 +57,7 @@ fn main() {
 
     for instruction in result {
         if let Err(e) = fs::write(output_path, instruction.encode().to_be_bytes()) {
-            eprintln!("Failed to write to output file: {}", e);
+            eprintln!("Failed to write to output file: {e}");
             std::process::exit(1);
         }
     }

assembler/src/tooling/mod.rs

@@ -1 +1,2 @@
+pub mod brainf;
 pub mod project;

c_compiler/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "c_compiler"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]
+chrono = "0.4.42"

c_compiler/code.c

@@ -0,0 +1,21 @@
+int x = 5;
+
+int add(int a, int b) { return a + b; }
+
+int factorial(int n) {
+  if (n <= 1) {
+    return 1;
+  }
+  return n * factorial(n - 1);
+}
+
+int main() {
+  int x;
+  x = 5;
+  int x = 5;
+  int result;
+  int result = 5;
+  result = x + factorial(5);
+  print(result);
+  return 0;
+}

c_compiler/compiler.py

@@ -0,0 +1,926 @@
+#!/usr/bin/env python3
+"""
+Simple C to DSA Assembly Compiler
+Supports a subset of C including:
+- int variables and functions
+- Arithmetic operations (+, -, *, /)
+- Comparisons (==, !=, <, >, <=, >=)
+- If/else statements
+- While loops
+- Function calls
+- Return statements
+"""
+
+import re
+import sys
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass
+from enum import Enum
+from pprint import pprint
+import json
+
+
+class TokenType(Enum):
+    # Keywords
+    INT = "int"
+    IF = "if"
+    ELSE = "else"
+    WHILE = "while"
+    RETURN = "return"
+
+    # Identifiers and literals
+    IDENTIFIER = "IDENTIFIER"
+    NUMBER = "NUMBER"
+
+    # Operators
+    PLUS = "+"
+    MINUS = "-"
+    STAR = "*"
+    SLASH = "/"
+    ASSIGN = "="
+    EQ = "=="
+    NE = "!="
+    LT = "<"
+    GT = ">"
+    LE = "<="
+    GE = ">="
+
+    # Delimiters
+    LPAREN = "("
+    RPAREN = ")"
+    LBRACE = "{"
+    RBRACE = "}"
+    SEMICOLON = ";"
+    COMMA = ","
+
+    EOF = "EOF"
+
+
+@dataclass
+class Token:
+    type: TokenType
+    value: str
+    line: int
+    col: int
+
+
+class Lexer:
+    def __init__(self, source: str):
+        self.source = source
+        self.pos = 0
+        self.line = 1
+        self.col = 1
+        self.tokens = []
+
+    def error(self, msg: str):
+        raise SyntaxError(f"Lexer error at line {self.line}, col {self.col}: {msg}")
+
+    def peek(self, offset: int = 0) -> Optional[str]:
+        pos = self.pos + offset
+        return self.source[pos] if pos < len(self.source) else None
+
+    def advance(self) -> Optional[str]:
+        if self.pos >= len(self.source):
+            return None
+        char = self.source[self.pos]
+        self.pos += 1
+        if char == "\n":
+            self.line += 1
+            self.col = 1
+        else:
+            self.col += 1
+        return char
+
+    def skip_whitespace(self):
+        while self.peek() and self.peek() in " \t\n\r":
+            self.advance()
+
+    def skip_comment(self):
+        if self.peek() == "/" and self.peek(1) == "/":
+            while self.peek() and self.peek() != "\n":
+                self.advance()
+            self.advance()  # skip newline
+
+    def read_number(self) -> str:
+        num = ""
+        while self.peek() and self.peek().isdigit():
+            num += self.advance()
+        return num
+
+    def read_identifier(self) -> str:
+        ident = ""
+        while self.peek() and (self.peek().isalnum() or self.peek() == "_"):
+            ident += self.advance()
+        return ident
+
+    def tokenize(self) -> List[Token]:
+        keywords = {
+            "int": TokenType.INT,
+            "if": TokenType.IF,
+            "else": TokenType.ELSE,
+            "while": TokenType.WHILE,
+            "return": TokenType.RETURN,
+        }
+
+        while self.pos < len(self.source):
+            self.skip_whitespace()
+            self.skip_comment()
+
+            if self.pos >= len(self.source):
+                break
+
+            line, col = self.line, self.col
+            char = self.peek()
+
+            # Numbers
+            if char.isdigit():
+                num = self.read_number()
+                self.tokens.append(Token(TokenType.NUMBER, num, line, col))
+
+            # Identifiers and keywords
+            elif char.isalpha() or char == "_":
+                ident = self.read_identifier()
+                token_type = keywords.get(ident, TokenType.IDENTIFIER)
+                self.tokens.append(Token(token_type, ident, line, col))
+
+            # Two-character operators
+            elif char == "=" and self.peek(1) == "=":
+                self.advance()
+                self.advance()
+                self.tokens.append(Token(TokenType.EQ, "==", line, col))
+            elif char == "!" and self.peek(1) == "=":
+                self.advance()
+                self.advance()
+                self.tokens.append(Token(TokenType.NE, "!=", line, col))
+            elif char == "<" and self.peek(1) == "=":
+                self.advance()
+                self.advance()
+                self.tokens.append(Token(TokenType.LE, "<=", line, col))
+            elif char == ">" and self.peek(1) == "=":
+                self.advance()
+                self.advance()
+                self.tokens.append(Token(TokenType.GE, ">=", line, col))
+
+            # Single-character operators
+            elif char == "+":
+                self.advance()
+                self.tokens.append(Token(TokenType.PLUS, "+", line, col))
+            elif char == "-":
+                self.advance()
+                self.tokens.append(Token(TokenType.MINUS, "-", line, col))
+            elif char == "*":
+                self.advance()
+                self.tokens.append(Token(TokenType.STAR, "*", line, col))
+            elif char == "/":
+                self.advance()
+                self.tokens.append(Token(TokenType.SLASH, "/", line, col))
+            elif char == "=":
+                self.advance()
+                self.tokens.append(Token(TokenType.ASSIGN, "=", line, col))
+            elif char == "<":
+                self.advance()
+                self.tokens.append(Token(TokenType.LT, "<", line, col))
+            elif char == ">":
+                self.advance()
+                self.tokens.append(Token(TokenType.GT, ">", line, col))
+            elif char == "(":
+                self.advance()
+                self.tokens.append(Token(TokenType.LPAREN, "(", line, col))
+            elif char == ")":
+                self.advance()
+                self.tokens.append(Token(TokenType.RPAREN, ")", line, col))
+            elif char == "{":
+                self.advance()
+                self.tokens.append(Token(TokenType.LBRACE, "{", line, col))
+            elif char == "}":
+                self.advance()
+                self.tokens.append(Token(TokenType.RBRACE, "}", line, col))
+            elif char == ";":
+                self.advance()
+                self.tokens.append(Token(TokenType.SEMICOLON, ";", line, col))
+            elif char == ",":
+                self.advance()
+                self.tokens.append(Token(TokenType.COMMA, ",", line, col))
+            else:
+                self.error(f"Unexpected character: {char}")
+
+        self.tokens.append(Token(TokenType.EOF, "", self.line, self.col))
+        return self.tokens
+
+
+# AST Node classes
+@dataclass
+class ASTNode:
+    pass
+
+
+@dataclass
+class Program(ASTNode):
+    declarations: List["Declaration"]
+
+
+@dataclass
+class Declaration(ASTNode):
+    pass
+
+
+@dataclass
+class FunctionDecl(Declaration):
+    name: str
+    params: List[str]
+    body: "CompoundStmt"
+
+
+@dataclass
+class VarDecl(Declaration):
+    name: str
+    init: Optional["Expression"] = None
+
+
+@dataclass
+class Statement(ASTNode):
+    pass
+
+
+@dataclass
+class CompoundStmt(Statement):
+    statements: List[Statement]
+
+
+@dataclass
+class ExprStmt(Statement):
+    expr: Optional["Expression"]
+
+
+@dataclass
+class IfStmt(Statement):
+    condition: "Expression"
+    then_stmt: Statement
+    else_stmt: Optional[Statement] = None
+
+
+@dataclass
+class WhileStmt(Statement):
+    condition: "Expression"
+    body: Statement
+
+
+@dataclass
+class ReturnStmt(Statement):
+    expr: Optional["Expression"]
+
+
+@dataclass
+class Expression(ASTNode):
+    pass
+
+
+@dataclass
+class BinaryOp(Expression):
+    op: str
+    left: Expression
+    right: Expression
+
+
+@dataclass
+class UnaryOp(Expression):
+    op: str
+    operand: Expression
+
+
+@dataclass
+class AssignExpr(Expression):
+    name: str
+    value: Expression
+
+
+@dataclass
+class VarExpr(Expression):
+    name: str
+
+
+@dataclass
+class NumberExpr(Expression):
+    value: int
+
+
+@dataclass
+class CallExpr(Expression):
+    name: str
+    args: List[Expression]
+
+
+class Parser:
+    def __init__(self, tokens: List[Token]):
+        self.tokens = tokens
+        self.pos = 0
+
+    def error(self, msg: str):
+        token = self.current()
+        raise SyntaxError(f"Parser error at line {token.line}, col {token.col}: {msg}")
+
+    def current(self) -> Token:
+        return self.tokens[self.pos] if self.pos < len(self.tokens) else self.tokens[-1]
+
+    def peek(self, offset: int = 0) -> Token:
+        pos = self.pos + offset
+        return self.tokens[pos] if pos < len(self.tokens) else self.tokens[-1]
+
+    def advance(self) -> Token:
+        token = self.current()
+        if self.pos < len(self.tokens) - 1:
+            self.pos += 1
+        return token
+
+    def expect(self, token_type: TokenType) -> Token:
+        token = self.current()
+        if token.type != token_type:
+            self.error(f"Expected {token_type.value}, got {token.type.value}")
+        return self.advance()
+
+    def parse(self) -> Program:
+        declarations = []
+        while self.current().type != TokenType.EOF:
+            declarations.append(self.parse_declaration())
+        return Program(declarations)
+
+    def parse_declaration(self) -> Declaration:
+        self.expect(TokenType.INT)
+        name = self.expect(TokenType.IDENTIFIER).value
+
+        if self.current().type == TokenType.LPAREN:
+            # Function declaration
+            self.advance()
+            params = []
+
+            if self.current().type != TokenType.RPAREN:
+                self.expect(TokenType.INT)
+                params.append(self.expect(TokenType.IDENTIFIER).value)
+
+                while self.current().type == TokenType.COMMA:
+                    self.advance()
+                    self.expect(TokenType.INT)
+                    params.append(self.expect(TokenType.IDENTIFIER).value)
+
+            self.expect(TokenType.RPAREN)
+            body = self.parse_compound_stmt()
+            return FunctionDecl(name, params, body)
+        else:
+            # Variable declaration
+            init = None
+            if self.current().type == TokenType.ASSIGN:
+                self.advance()
+                init = self.parse_expression()
+            self.expect(TokenType.SEMICOLON)
+            return VarDecl(name, init)
+
+    def parse_compound_stmt(self) -> CompoundStmt:
+        self.expect(TokenType.LBRACE)
+        statements = []
+
+        while self.current().type != TokenType.RBRACE:
+            statements.append(self.parse_statement())
+
+        self.expect(TokenType.RBRACE)
+        return CompoundStmt(statements)
+
+    def parse_statement(self) -> Statement:
+        token = self.current()
+
+        if token.type == TokenType.LBRACE:
+            return self.parse_compound_stmt()
+        elif token.type == TokenType.IF:
+            return self.parse_if_stmt()
+        elif token.type == TokenType.WHILE:
+            return self.parse_while_stmt()
+        elif token.type == TokenType.RETURN:
+            return self.parse_return_stmt()
+        elif token.type == TokenType.INT:
+            # Local variable declaration
+            self.advance()
+            name = self.expect(TokenType.IDENTIFIER).value
+            init = None
+            if self.current().type == TokenType.ASSIGN:
+                self.advance()
+                init = self.parse_expression()
+            self.expect(TokenType.SEMICOLON)
+            return ExprStmt(AssignExpr(name, init) if init else None)
+        else:
+            expr = (
+                self.parse_expression()
+                if self.current().type != TokenType.SEMICOLON
+                else None
+            )
+            self.expect(TokenType.SEMICOLON)
+            return ExprStmt(expr)
+
+    def parse_if_stmt(self) -> IfStmt:
+        self.expect(TokenType.IF)
+        self.expect(TokenType.LPAREN)
+        condition = self.parse_expression()
+        self.expect(TokenType.RPAREN)
+        then_stmt = self.parse_statement()
+
+        else_stmt = None
+        if self.current().type == TokenType.ELSE:
+            self.advance()
+            else_stmt = self.parse_statement()
+
+        return IfStmt(condition, then_stmt, else_stmt)
+
+    def parse_while_stmt(self) -> WhileStmt:
+        self.expect(TokenType.WHILE)
+        self.expect(TokenType.LPAREN)
+        condition = self.parse_expression()
+        self.expect(TokenType.RPAREN)
+        body = self.parse_statement()
+        return WhileStmt(condition, body)
+
+    def parse_return_stmt(self) -> ReturnStmt:
+        self.expect(TokenType.RETURN)
+        expr = None
+        if self.current().type != TokenType.SEMICOLON:
+            expr = self.parse_expression()
+        self.expect(TokenType.SEMICOLON)
+        return ReturnStmt(expr)
+
+    def parse_expression(self) -> Expression:
+        return self.parse_assignment()
+
+    def parse_assignment(self) -> Expression:
+        expr = self.parse_comparison()
+
+        if self.current().type == TokenType.ASSIGN:
+            if not isinstance(expr, VarExpr):
+                self.error("Invalid assignment target")
+            self.advance()
+            value = self.parse_assignment()
+            return AssignExpr(expr.name, value)
+
+        return expr
+
+    def parse_comparison(self) -> Expression:
+        expr = self.parse_additive()
+
+        while self.current().type in [
+            TokenType.EQ,
+            TokenType.NE,
+            TokenType.LT,
+            TokenType.GT,
+            TokenType.LE,
+            TokenType.GE,
+        ]:
+            op = self.advance().value
+            right = self.parse_additive()
+            expr = BinaryOp(op, expr, right)
+
+        return expr
+
+    def parse_additive(self) -> Expression:
+        expr = self.parse_multiplicative()
+
+        while self.current().type in [TokenType.PLUS, TokenType.MINUS]:
+            op = self.advance().value
+            right = self.parse_multiplicative()
+            expr = BinaryOp(op, expr, right)
+
+        return expr
+
+    def parse_multiplicative(self) -> Expression:
+        expr = self.parse_unary()
+
+        while self.current().type in [TokenType.STAR, TokenType.SLASH]:
+            op = self.advance().value
+            right = self.parse_unary()
+            expr = BinaryOp(op, expr, right)
+
+        return expr
+
+    def parse_unary(self) -> Expression:
+        if self.current().type in [TokenType.PLUS, TokenType.MINUS]:
+            op = self.advance().value
+            operand = self.parse_unary()
+            return UnaryOp(op, operand)
+
+        return self.parse_primary()
+
+    def parse_primary(self) -> Expression:
+        token = self.current()
+
+        if token.type == TokenType.NUMBER:
+            self.advance()
+            return NumberExpr(int(token.value))
+
+        elif token.type == TokenType.IDENTIFIER:
+            name = self.advance().value
+
+            if self.current().type == TokenType.LPAREN:
+                # Function call
+                self.advance()
+                args = []
+
+                if self.current().type != TokenType.RPAREN:
+                    args.append(self.parse_expression())
+                    while self.current().type == TokenType.COMMA:
+                        self.advance()
+                        args.append(self.parse_expression())
+
+                self.expect(TokenType.RPAREN)
+                return CallExpr(name, args)
+            else:
+                return VarExpr(name)
+
+        elif token.type == TokenType.LPAREN:
+            self.advance()
+            expr = self.parse_expression()
+            self.expect(TokenType.RPAREN)
+            return expr
+
+        else:
+            self.error(f"Unexpected token: {token.type.value}")
+
+
+class CodeGenerator:
+    def __init__(self):
+        self.output = []
+        self.label_counter = 0
+        self.string_counter = 0
+        self.functions = {}
+        self.current_function = None
+        self.local_vars = {}
+        self.global_vars = {}
+        self.register_pool = [f"rg{i:x}" for i in range(16)]
+        self.used_registers = set()
+
+    def new_label(self, prefix: str = "L") -> str:
+        label = f"{prefix}{self.label_counter}"
+        self.label_counter += 1
+        return label
+
+    def allocate_register(self) -> str:
+        for reg in self.register_pool:
+            if reg not in self.used_registers:
+                self.used_registers.add(reg)
+                return reg
+        raise RuntimeError("Out of registers")
+
+    def free_register(self, reg: str):
+        self.used_registers.discard(reg)
+
+    def emit(self, code: str):
+        self.output.append(code)
+
+    def generate(self, program: Program) -> str:
+        # Emit data section
+        self.emit("// Global variables")
+        for decl in program.declarations:
+            if isinstance(decl, VarDecl):
+                self.global_vars[decl.name] = f"var_{decl.name}"
+                if decl.init:
+                    if isinstance(decl.init, NumberExpr):
+                        self.emit(f"dw var_{decl.name}: {decl.init.value}")
+                    else:
+                        self.emit(f"dw var_{decl.name}: 0")
+                else:
+                    self.emit(f"dw var_{decl.name}: 0")
+
+        self.emit("")
+        self.emit("// Entry point")
+        self.emit("dw stack_bottom: 0x10000")
+        self.emit("")
+        self.emit("init:")
+        self.emit("    ldw stack_bottom, spr")
+        self.emit("    mov spr, bpr")
+
+        self.emit("    push zero")
+        self.emit("    call main")
+        self.emit("    pop rg0")
+        self.emit("    hlt")
+        self.emit("")
+
+        # Emit functions
+        for decl in program.declarations:
+            if isinstance(decl, FunctionDecl):
+                self.generate_function(decl)
+
+        return "\n".join(self.output)
+
+    def generate_function(self, func: FunctionDecl):
+        self.current_function = func.name
+        self.functions[func.name] = func
+        self.local_vars = {}
+
+        # Map parameters to stack offsets
+        # Parameters start at bpr+8 (after return addr at bpr+4)
+        for i, param in enumerate(func.params):
+            self.local_vars[param] = 8 + (i * 4)
+
+        self.emit(f"{func.name}:")
+        self.emit("    push bpr")
+        self.emit("    mov spr, bpr")
+        self.emit("")
+
+        # Generate function body
+        self.generate_compound_stmt(func.body)
+
+        # Default return if no explicit return
+        self.emit("// default return")
+        self.emit(f"{func.name}_end:")
+        self.emit("    mov bpr, spr")
+        self.emit("    pop bpr")
+        self.emit("    return")
+        self.emit("")
+
+    def generate_compound_stmt(self, stmt: CompoundStmt):
+        for s in stmt.statements:
+            self.generate_statement(s)
+
+    def generate_statement(self, stmt: Statement):
+        if isinstance(stmt, CompoundStmt):
+            self.generate_compound_stmt(stmt)
+        elif isinstance(stmt, ExprStmt):
+            if stmt.expr:
+                reg = self.generate_expression(stmt.expr)
+                self.free_register(reg)
+        elif isinstance(stmt, IfStmt):
+            self.generate_if_stmt(stmt)
+        elif isinstance(stmt, WhileStmt):
+            self.generate_while_stmt(stmt)
+        elif isinstance(stmt, ReturnStmt):
+            self.generate_return_stmt(stmt)
+
+    def generate_if_stmt(self, stmt: IfStmt):
+        else_label = self.new_label("else")
+        end_label = self.new_label("endif")
+
+        # Evaluate condition
+        cond_reg = self.generate_expression(stmt.condition)
+        self.emit(f"    cmp {cond_reg}, zero")
+        self.free_register(cond_reg)
+
+        if stmt.else_stmt:
+            self.emit(f"    jeq {else_label}")
+        else:
+            self.emit(f"    jeq {end_label}")
+
+        # Then branch
+        self.generate_statement(stmt.then_stmt)
+
+        if stmt.else_stmt:
+            self.emit(f"    jmp {end_label}")
+            self.emit(f"{else_label}:")
+            self.generate_statement(stmt.else_stmt)
+
+        self.emit(f"{end_label}:")
+
+    def generate_while_stmt(self, stmt: WhileStmt):
+        start_label = self.new_label("while_start")
+        end_label = self.new_label("while_end")
+
+        self.emit(f"{start_label}:")
+
+        # Evaluate condition
+        cond_reg = self.generate_expression(stmt.condition)
+        self.emit(f"    cmp {cond_reg}, zero")
+        self.free_register(cond_reg)
+        self.emit(f"    jeq {end_label}")
+
+        # Loop body
+        self.generate_statement(stmt.body)
+        self.emit(f"    jmp {start_label}")
+
+        self.emit(f"{end_label}:")
+
+    def generate_return_stmt(self, stmt: ReturnStmt):
+        if stmt.expr:
+            reg = self.generate_expression(stmt.expr)
+            # Store return value at spr+8 according to calling convention
+            self.emit(f"    stw {reg}, spr, 8")
+            self.free_register(reg)
+        self.emit(f"    jmp {self.current_function}_end")
+
+    def generate_expression(self, expr: Expression) -> str:
+        if isinstance(expr, NumberExpr):
+            reg = self.allocate_register()
+            if expr.value <= 0xFFFF and expr.value >= 0:
+                self.emit(f"    lli {expr.value}, {reg}")
+                if expr.value > 0xFF:
+                    self.emit(f"    lui {expr.value >> 16}, {reg}")
+            else:
+                self.emit(f"    lli {expr.value & 0xFFFF}, {reg}")
+                self.emit(f"    lui {(expr.value >> 16) & 0xFFFF}, {reg}")
+            return reg
+
+        elif isinstance(expr, VarExpr):
+            reg = self.allocate_register()
+            if expr.name in self.local_vars:
+                offset = self.local_vars[expr.name]
+                self.emit(f"    ldw bpr, {reg}, {offset}")
+            elif expr.name in self.global_vars:
+                label = self.global_vars[expr.name]
+                self.emit(f"    ldw {label}, {reg}")
+            else:
+                raise RuntimeError(f"Undefined variable: {expr.name}")
+            return reg
+
+        elif isinstance(expr, AssignExpr):
+            value_reg = self.generate_expression(expr.value)
+
+            if expr.name in self.local_vars:
+                offset = self.local_vars[expr.name]
+                self.emit(f"    stw {value_reg}, bpr, {offset}")
+            elif expr.name in self.global_vars:
+                label = self.global_vars[expr.name]
+                self.emit(f"    stw {value_reg}, {label}")
+            else:
+                # New local variable - allocate after params and return value space
+                # Start local variables at offset -4 from bpr (growing downward)
+                offset = -(len([v for v in self.local_vars.values() if v < 0]) + 1) * 4
+                self.local_vars[expr.name] = offset
+                self.emit(f"    stw {value_reg}, bpr, {offset}")
+
+            return value_reg
+
+        elif isinstance(expr, BinaryOp):
+            return self.generate_binary_op(expr)
+
+        elif isinstance(expr, UnaryOp):
+            operand_reg = self.generate_expression(expr.operand)
+            result_reg = self.allocate_register()
+
+            if expr.op == "-":
+                self.emit(f"    lwi 0, {result_reg}")
+                self.emit(f"    sub {result_reg}, {operand_reg}, {result_reg}")
+            else:  # +
+                self.emit(f"    mov {operand_reg}, {result_reg}")
+
+            self.free_register(operand_reg)
+            return result_reg
+
+        elif isinstance(expr, CallExpr):
+            # First, make space for return value (must be pushed BEFORE arguments)
+            temp_reg = self.allocate_register()
+
+            # Then push arguments in reverse order
+            arg_regs = []
+            for arg in reversed(expr.args):
+                reg = self.generate_expression(arg)
+                self.emit(f"    push {reg}")
+                arg_regs.append(reg)
+
+            # Call function
+            self.emit(f"    call {expr.name}")
+
+            # Get return value (it's now on top of stack)
+            self.emit(f"    pop {temp_reg}")
+
+            # Clean up remaining args
+            for i in range(len(arg_regs) - 1):
+                self.emit(f"    pop zero")
+
+            # Free the arg registers
+            for reg in arg_regs:
+                self.free_register(reg)
+
+            return temp_reg
+
+        else:
+            raise RuntimeError(f"Unknown expression type: {type(expr)}")
+
+    def generate_binary_op(self, expr: BinaryOp) -> str:
+        # For operations that might contain function calls, we need to be careful
+        # about register allocation. Evaluate left, save it, evaluate right.
+        left_reg = self.generate_expression(expr.left)
+
+        # If right side contains a function call, we need to save left_reg
+        # For now, always save to be safe
+        saved_reg = self.allocate_register()
+        self.emit(f"    mov {left_reg}, {saved_reg}")
+        self.free_register(left_reg)
+
+        right_reg = self.generate_expression(expr.right)
+        result_reg = self.allocate_register()
+
+        if expr.op == "+":
+            self.emit(f"    add {left_reg}, {right_reg}, {result_reg}")
+        elif expr.op == "-":
+            self.emit(f"    sub {left_reg}, {right_reg}, {result_reg}")
+        elif expr.op == "*":
+            # Simple multiplication using loop
+            temp_label = self.new_label("mult")
+            end_label = self.new_label("mult_end")
+            self.emit(f"    lli 0, {result_reg}")
+            self.emit(f"{temp_label}:")
+            self.emit(f"    cmp {right_reg}, zero")
+            self.emit(f"    jeq {end_label}")
+            self.emit(f"    add {result_reg}, {left_reg}, {result_reg}")
+            self.emit(f"    dec {right_reg}")
+            self.emit(f"    jmp {temp_label}")
+            self.emit(f"{end_label}:")
+        elif expr.op == "/":
+            # Simple division using loop
+            temp_label = self.new_label("div")
+            end_label = self.new_label("div_end")
+            self.emit(f"    lli 0, {result_reg}")
+            self.emit(f"{temp_label}:")
+            self.emit(f"    cmp {left_reg}, {right_reg}")
+            self.emit(f"    jlt {end_label}")
+            self.emit(f"    sub {left_reg}, {right_reg}, {left_reg}")
+            self.emit(f"    inc {result_reg}")
+            self.emit(f"    jmp {temp_label}")
+            self.emit(f"{end_label}:")
+        elif expr.op in ["==", "!=", "<", ">", "<=", ">="]:
+            self.emit(f"    cmp {left_reg}, {right_reg}")
+
+            # Result is 1 if condition true, 0 otherwise
+            self.emit(f"    lli 0, {result_reg}")
+            true_label = self.new_label("cmp_true")
+            end_label = self.new_label("cmp_end")
+
+            if expr.op == "==":
+                self.emit(f"    jeq {true_label}")
+            elif expr.op == "!=":
+                self.emit(f"    jne {true_label}")
+            elif expr.op == "<":
+                self.emit(f"    jlt {true_label}")
+            elif expr.op == ">":
+                self.emit(f"    jgt {true_label}")
+            elif expr.op == "<=":
+                self.emit(f"    jle {true_label}")
+            elif expr.op == ">=":
+                self.emit(f"    jge {true_label}")
+
+            self.emit(f"    jmp {end_label}")
+            self.emit(f"{true_label}:")
+            self.emit(f"    lli 1, {result_reg}")
+            self.emit(f"{end_label}:")
+
+        self.free_register(left_reg)
+        self.free_register(right_reg)
+        return result_reg
+
+
+def compile_c_to_asm(source: str) -> str:
+    """Compile C source code to DSA assembly."""
+    lexer = Lexer(source)
+    tokens = lexer.tokenize()
+
+    parser = Parser(tokens)
+    ast = parser.parse()
+
+    codegen = CodeGenerator()
+    assembly = codegen.generate(ast)
+
+    return assembly
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python compiler.py <input.c> [output.dsa]")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+    output_file = sys.argv[2] if len(sys.argv) > 2 else input_file.replace(".c", ".dsa")
+
+    with open(input_file, "r") as f:
+        source = f.read()
+
+    try:
+        assembly = compile_c_to_asm(source)
+
+        with open(output_file, "w") as f:
+            f.write(assembly)
+
+        print(f"Successfully compiled {input_file} to {output_file}")
+    except (SyntaxError, RuntimeError) as e:
+        print(f"Compilation error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
+    # # Example usage
+    # if len(sys.argv) > 1:
+    #     example_c = sys.argv[1]
+
+    # else:
+    #     example_c = """
+    # int factorial(int n) {
+    #     if (n <= 1) {
+    #         return 1;
+    #     }
+    #     return n * factorial(n - 1);
+    # }
+
+    # int main() {
+    #     int result;
+    #     result = factorial(5);
+    #     return result;
+    # }
+    #     """
+
+    # print("Example C program:")
+    # print(example_c)
+    # print("\n" + "="*60 + "\n")
+    # print("Generated DSA assembly:")
+    # print(compile_c_to_asm(example_c))

c_compiler/output.dsa

@@ -0,0 +1,5 @@
+// Imports
+include maths: "./lib/maths/core.dsa"
+
+// Reserved Memory
+

c_compiler/src/codegen.rs

@@ -0,0 +1,193 @@
+use std::time::SystemTime;
+use std::{collections::HashMap, path::PathBuf};
+
+use chrono::{DateTime, Local};
+
+use crate::{block, cmd, comment, dsa};
+
+use crate::parser::{ConstExpr, Declaration, Program};
+
+pub struct CodeGenerator {
+    ast: Program,
+    imports: HashMap<String, String>,
+    globals: Vec<String>,
+    functions: Vec<String>,
+}
+
+fn import(name: &str, path: &str) -> String {
+    format!("include {name}: \"{}\"", path)
+}
+
+impl CodeGenerator {
+    pub fn new(ast: Program) -> Self {
+        CodeGenerator {
+            ast,
+            imports: HashMap::new(),
+            globals: Vec::new(),
+            functions: Vec::new(),
+        }
+    }
+
+    pub fn include(&mut self, name: &str, path: &str) {
+        self.imports.insert(name.to_string(), path.to_string());
+    }
+
+    pub fn generate(&mut self) -> Result<String, String> {
+        // always include the print library for debugging!
+        self.include("print", "./lib/io/print.dsa");
+
+        for block in self.ast.clone().declarations {
+            self.generate_block(block.clone());
+        }
+
+        self.generate_layout()
+    }
+
+    fn generate_block(&mut self, block: Declaration) {
+        match block {
+            Declaration::Variable { name, init } => self.globals.push(format!(
+                "dw {}: {}",
+                name,
+                init.unwrap_or(ConstExpr::Number(0))
+            )),
+            Declaration::Function {
+                name,
+                return_type,
+                params,
+                body,
+            } => {
+                let function_start = format!(
+                    "{name}: \n\t\
+                    push bpr \n\t\
+                    mov spr, bpr"
+                );
+
+                let function_end = format!(
+                    "\n\t\
+                    mov bpr, spr \n\t\
+                    pop bpr \n\t\
+                    return\n"
+                );
+
+                self.functions
+                    .push(format!("{function_start}\n{function_end}"));
+            }
+        }
+    }
+
+    fn generate_layout(&mut self) -> Result<String, String> {
+        let datetime: DateTime<Local> = SystemTime::now().into();
+        Ok(dsa![
+            "",
+            comment!("GENERATED BY DSA-C COMPILER"),
+            comment!(format!(
+                "Generated at {}",
+                datetime.format("%Y-%m-%d %H:%M:%S")
+            )),
+            "",
+            // imports
+            comment!("Imports"),
+            self.imports
+                .iter()
+                .map(|(k, v)| import(k, v))
+                .collect::<Vec<String>>()
+                .join("\n"),
+            "",
+            // reserved memory
+            comment!("Globals & Reserved Memory"),
+            self.globals.join("\n"),
+            "",
+            // entry point
+            comment!("Entry Point"),
+            "dw stack: 0x10000",
+            "db message: \"Process Exited with code:\"",
+            block! [ "_init"
+                dsa![ldw stack, bpr],
+                dsa![mov bpr, spr],
+                dsa![push zero],
+                dsa![call main],
+                dsa![lwi message, rg0],
+                dsa![push rg0],
+                dsa![call print::print],
+                dsa![pop zero],
+                dsa![call print::print_hex_word],
+                dsa![pop zero],
+                dsa![hlt]
+            ],
+            block! [ "main"
+                dsa![push bpr],
+                dsa![mov spr, bpr],
+                dsa![lwi 67, rg1],
+                dsa![stw rg1, spr, 8],
+                dsa![mov bpr, spr],
+                dsa![pop bpr],
+                dsa![return]
+            ],
+            "",
+            self.functions.join("\n"),
+        ])
+    }
+}
+
+/// Build a single string from any number of arguments.
+/// Each argument must implement `Display` or be convertible to a string.
+#[macro_export]
+macro_rules! dsa {
+    ($($arg:expr),* $(,)?) => {{
+        // Start with an empty String – we’ll grow it as we go.
+        use std::fmt::Write;
+        let mut s = ::std::string::String::new();
+        $(
+            // `write!` is cheaper than `format!` for each element
+            // because it re‑uses the same buffer.
+
+            write!(s, "{}\n", $arg).expect("write to String failed");
+        )*
+        s
+    }};
+}
+
+// ────────────────────────  dsa!  ────────────────────────
+// A tiny helper that just turns its token‑stream into a string.
+// The trailing comma is kept – it’s part of the syntax you want.
+#[macro_export]
+macro_rules! cmd {
+    ($($tokens:tt)*) => {{
+        // We’ll just stringify the tokens and return a String.
+        format!("{}", concat!(stringify!($tokens), "\n"))
+    }};
+}
+
+// ────────────────────────  block!  ────────────────────────
+// Usage:
+//
+//   let asm = block![ "name"
+//       dsa![mov rg0, rg1],
+//       dsa![add rg1, rg1]
+//   ];
+//
+// `asm` is a `&'static str` containing:
+//
+//   name:
+//       mov rg0, rg1
+//       add rg1, rg1
+//
+#[macro_export]
+macro_rules! block {
+    // The first token must be a string literal – that’s the label.
+    ($label:literal $(dsa![$($ins:tt)*]),* ) => {{
+        // Build a single string at compile time.
+        const CODE: &str = concat!(
+            $label, ":\n",
+            // Each `dsa!` call yields a string like `"mov rg0, rg1"`.
+            // We add a newline after each one to get the desired layout.
+            $(concat!("\t", stringify!($($ins)*), "\n")),*
+        );
+        CODE
+    }};
+}
+
+#[macro_export]
+macro_rules! comment {
+    ($text:expr) => {{ format!("// {}", $text) }};
+}

c_compiler/src/lexer.rs

@@ -0,0 +1,265 @@
+// ============================================================================
+// Token Types
+// ============================================================================
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum TokenType {
+    // Keywords
+    Int,
+    If,
+    Else,
+    While,
+    Return,
+
+    // Identifiers and literals
+    Identifier(String),
+    Number(i32),
+
+    // Operators
+    Plus,
+    Minus,
+    Star,
+    Slash,
+    Assign,
+    Eq,
+    Ne,
+    Lt,
+    Gt,
+    Le,
+    Ge,
+
+    // Delimiters
+    LParen,
+    RParen,
+    LBrace,
+    RBrace,
+    Semicolon,
+    Comma,
+
+    Eof,
+}
+
+#[derive(Debug, Clone)]
+pub struct Token {
+    pub token_type: TokenType,
+    pub line: usize,
+    pub col: usize,
+}
+
+impl Token {
+    pub fn new(token_type: TokenType, line: usize, col: usize) -> Self {
+        Self {
+            token_type,
+            line,
+            col,
+        }
+    }
+}
+
+// ============================================================================
+// Lexer
+// ============================================================================
+
+pub struct Lexer {
+    source: Vec<char>,
+    pos: usize,
+    line: usize,
+    col: usize,
+}
+
+impl Lexer {
+    pub fn new(source: &str) -> Self {
+        Self {
+            source: source.chars().collect(),
+            pos: 0,
+            line: 1,
+            col: 1,
+        }
+    }
+
+    fn error(&self, msg: &str) -> String {
+        format!(
+            "Lexer error at line {}, col {}: {}",
+            self.line, self.col, msg
+        )
+    }
+
+    fn peek(&self, offset: usize) -> Option<char> {
+        self.source.get(self.pos + offset).copied()
+    }
+
+    fn advance(&mut self) -> Option<char> {
+        if self.pos >= self.source.len() {
+            return None;
+        }
+        let ch = self.source[self.pos];
+        self.pos += 1;
+        if ch == '\n' {
+            self.line += 1;
+            self.col = 1;
+        } else {
+            self.col += 1;
+        }
+        Some(ch)
+    }
+
+    fn skip_whitespace(&mut self) {
+        while let Some(ch) = self.peek(0) {
+            if ch.is_whitespace() {
+                self.advance();
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn skip_comment(&mut self) {
+        if self.peek(0) == Some('/') && self.peek(1) == Some('/') {
+            while let Some(ch) = self.peek(0) {
+                if ch == '\n' {
+                    break;
+                }
+                self.advance();
+            }
+        }
+    }
+
+    fn read_number(&mut self) -> i32 {
+        let mut num_str = String::new();
+        while let Some(ch) = self.peek(0) {
+            if ch.is_ascii_digit() {
+                num_str.push(ch);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        num_str.parse().unwrap_or(0)
+    }
+
+    fn read_identifier(&mut self) -> String {
+        let mut ident = String::new();
+        while let Some(ch) = self.peek(0) {
+            if ch.is_alphanumeric() || ch == '_' {
+                ident.push(ch);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        ident
+    }
+
+    pub fn tokenize(&mut self) -> Result<Vec<Token>, String> {
+        let mut tokens = Vec::new();
+
+        loop {
+            self.skip_whitespace();
+            self.skip_comment();
+
+            if self.pos >= self.source.len() {
+                break;
+            }
+
+            let line = self.line;
+            let col = self.col;
+            let ch = self.peek(0).unwrap();
+
+            let token_type = if ch.is_ascii_digit() {
+                let num = self.read_number();
+                TokenType::Number(num)
+            } else if ch.is_alphabetic() || ch == '_' {
+                let ident = self.read_identifier();
+                match ident.as_str() {
+                    "int" => TokenType::Int,
+                    "if" => TokenType::If,
+                    "else" => TokenType::Else,
+                    "while" => TokenType::While,
+                    "return" => TokenType::Return,
+                    _ => TokenType::Identifier(ident),
+                }
+            } else {
+                match ch {
+                    '=' if self.peek(1) == Some('=') => {
+                        self.advance();
+                        self.advance();
+                        TokenType::Eq
+                    }
+                    '!' if self.peek(1) == Some('=') => {
+                        self.advance();
+                        self.advance();
+                        TokenType::Ne
+                    }
+                    '<' if self.peek(1) == Some('=') => {
+                        self.advance();
+                        self.advance();
+                        TokenType::Le
+                    }
+                    '>' if self.peek(1) == Some('=') => {
+                        self.advance();
+                        self.advance();
+                        TokenType::Ge
+                    }
+                    '+' => {
+                        self.advance();
+                        TokenType::Plus
+                    }
+                    '-' => {
+                        self.advance();
+                        TokenType::Minus
+                    }
+                    '*' => {
+                        self.advance();
+                        TokenType::Star
+                    }
+                    '/' => {
+                        self.advance();
+                        TokenType::Slash
+                    }
+                    '=' => {
+                        self.advance();
+                        TokenType::Assign
+                    }
+                    '<' => {
+                        self.advance();
+                        TokenType::Lt
+                    }
+                    '>' => {
+                        self.advance();
+                        TokenType::Gt
+                    }
+                    '(' => {
+                        self.advance();
+                        TokenType::LParen
+                    }
+                    ')' => {
+                        self.advance();
+                        TokenType::RParen
+                    }
+                    '{' => {
+                        self.advance();
+                        TokenType::LBrace
+                    }
+                    '}' => {
+                        self.advance();
+                        TokenType::RBrace
+                    }
+                    ';' => {
+                        self.advance();
+                        TokenType::Semicolon
+                    }
+                    ',' => {
+                        self.advance();
+                        TokenType::Comma
+                    }
+                    _ => return Err(self.error(&format!("Unexpected character: {}", ch))),
+                }
+            };
+
+            tokens.push(Token::new(token_type, line, col));
+        }
+
+        tokens.push(Token::new(TokenType::Eof, self.line, self.col));
+        Ok(tokens)
+    }
+}

c_compiler/src/main.rs

@@ -0,0 +1,72 @@
+use std::fmt;
+
+use crate::{codegen::CodeGenerator, lexer::Lexer, parser::Parser};
+
+pub mod codegen;
+pub mod lexer;
+pub mod parser;
+
+// ============================================================================
+// Main & Tests
+// ============================================================================
+
+fn main() {
+    // read from input file: syntax "c_compiler <src.c> [output.dsa]"
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() < 2 {
+        eprintln!("Usage: c_compiler <src.c> [output.dsa]");
+        return;
+    }
+
+    let input_file = &args[1];
+    let output_file = if args.len() > 2 {
+        &args[2]
+    } else {
+        "output.dsa"
+    };
+
+    // read input
+    let input = std::fs::read_to_string(input_file).expect("Failed to read input file");
+
+    // Lexing
+    let mut lexer = Lexer::new(&input);
+    let tokens = match lexer.tokenize() {
+        Ok(tokens) => tokens,
+        Err(e) => {
+            eprintln!("Lexing error: {}", e);
+            return;
+        }
+    };
+
+    println!("Tokens:");
+    for token in &tokens {
+        println!("  {:?}", token.token_type);
+    }
+    println!();
+
+    // Parsing
+    let mut parser = Parser::new(tokens);
+    let ast = match parser.parse() {
+        Ok(ast) => ast,
+        Err(e) => {
+            eprintln!("Parsing error: {}", e);
+            return;
+        }
+    };
+
+    println!("AST:");
+    println!("{:#?}", ast);
+
+    // Code Gen
+    let mut generator = CodeGenerator::new(ast);
+    let result = match generator.generate() {
+        Ok(code) => code,
+        Err(e) => {
+            eprintln!("Parsing error: {}", e);
+            return;
+        }
+    };
+
+    std::fs::write(output_file, &result).expect("Failed to write output");
+    println!("Result written to {}", output_file);
+}

c_compiler/src/parser.rs

@@ -0,0 +1,580 @@
+// ============================================================================
+// AST Node Types
+// ============================================================================
+
+use std::fmt;
+
+use crate::lexer::{Token, TokenType};
+
+#[derive(Debug, Clone)]
+pub struct Program {
+    pub declarations: Vec<Declaration>,
+}
+
+#[derive(Debug, Clone)]
+pub enum Declaration {
+    Function {
+        name: String,
+        return_type: Type,
+        params: Vec<Parameter>,
+        body: Statement,
+    },
+    Variable {
+        name: String,
+        init: Option<ConstExpr>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct Parameter {
+    pub name: String,
+    pub param_type: Type,
+}
+
+#[derive(Debug, Clone)]
+pub enum Type {
+    Int,
+    Long,
+    Float,
+    Double,
+    Char,
+    Void,
+    Ptr(Box<Type>),
+    Array(Box<Type>, usize),
+    Struct(String),
+}
+
+#[derive(Debug, Clone)]
+pub enum Statement {
+    Compound {
+        statements: Vec<Statement>,
+    },
+    Assign {
+        // left side
+        name: String,
+        declare_type: Option<Type>,
+
+        // right side
+        value: Option<Box<Expression>>,
+    },
+    Expression {
+        expr: Expression,
+    },
+    If {
+        condition: Expression,
+        then_stmt: Box<Statement>,
+        else_stmt: Option<Box<Statement>>,
+    },
+    While {
+        condition: Expression,
+        body: Box<Statement>,
+    },
+    Return {
+        expr: Option<Expression>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub enum ConstExpr {
+    Number(i32),
+    String(String),
+}
+
+impl fmt::Display for ConstExpr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ConstExpr::Number(n) => write!(f, "{}", n),
+            ConstExpr::String(s) => write!(f, "\"{}\"", s),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Expression {
+    Empty,
+    Binary {
+        op: BinaryOperator,
+        left: Box<Expression>,
+        right: Box<Expression>,
+    },
+    Unary {
+        op: UnaryOperator,
+        operand: Box<Expression>,
+    },
+    Variable {
+        name: String,
+        expr_type: Option<Type>,
+    },
+    Number {
+        value: i32,
+    },
+    Call {
+        name: String,
+        args: Vec<Expression>,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum BinaryOperator {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Eq,
+    Ne,
+    Lt,
+    Gt,
+    Le,
+    Ge,
+}
+
+impl fmt::Display for BinaryOperator {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BinaryOperator::Add => write!(f, "+"),
+            BinaryOperator::Sub => write!(f, "-"),
+            BinaryOperator::Mul => write!(f, "*"),
+            BinaryOperator::Div => write!(f, "/"),
+            BinaryOperator::Eq => write!(f, "=="),
+            BinaryOperator::Ne => write!(f, "!="),
+            BinaryOperator::Lt => write!(f, "<"),
+            BinaryOperator::Gt => write!(f, ">"),
+            BinaryOperator::Le => write!(f, "<="),
+            BinaryOperator::Ge => write!(f, ">="),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum UnaryOperator {
+    Plus,
+    Minus,
+}
+
+impl fmt::Display for UnaryOperator {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            UnaryOperator::Plus => write!(f, "+"),
+            UnaryOperator::Minus => write!(f, "-"),
+        }
+    }
+}
+
+// ============================================================================
+// Parser
+// ============================================================================
+
+pub struct Parser {
+    tokens: Vec<Token>,
+    pos: usize,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Self { tokens, pos: 0 }
+    }
+
+    fn error(&self, msg: &str) -> String {
+        let token = self.current();
+        format!(
+            "Parser error at line {}, col {}: {}",
+            token.line, token.col, msg
+        )
+    }
+
+    fn current(&self) -> &Token {
+        self.tokens
+            .get(self.pos)
+            .unwrap_or_else(|| self.tokens.last().unwrap())
+    }
+
+    fn peek(&self, offset: usize) -> &Token {
+        self.tokens
+            .get(self.pos + offset)
+            .unwrap_or_else(|| self.tokens.last().unwrap())
+    }
+
+    fn advance(&mut self) -> &Token {
+        if self.pos < self.tokens.len() - 1 {
+            self.pos += 1;
+        }
+        self.current()
+    }
+
+    fn expect(&mut self, expected: TokenType) -> Result<Token, String> {
+        let token = self.current().clone();
+        if std::mem::discriminant(&token.token_type) != std::mem::discriminant(&expected)
+        {
+            return Err(self.error(&format!(
+                "Expected {:?}, got {:?}",
+                expected, token.token_type
+            )));
+        }
+        self.advance();
+        Ok(token)
+    }
+
+    pub fn parse(&mut self) -> Result<Program, String> {
+        let mut declarations = Vec::new();
+
+        while !matches!(self.current().token_type, TokenType::Eof) {
+            declarations.push(self.parse_declaration()?);
+        }
+
+        Ok(Program { declarations })
+    }
+
+    fn parse_declaration(&mut self) -> Result<Declaration, String> {
+        self.expect(TokenType::Int)?;
+
+        let name = match &self.current().token_type {
+            TokenType::Identifier(s) => s.clone(),
+            _ => return Err(self.error("Expected identifier")),
+        };
+        self.advance();
+
+        match &self.current().token_type {
+            TokenType::LParen => {
+                // Function declaration
+                self.advance();
+                let mut params = Vec::<Parameter>::new();
+
+                if !matches!(self.current().token_type, TokenType::RParen) {
+                    self.expect(TokenType::Int)?;
+
+                    match &self.current().token_type {
+                        TokenType::Identifier(s) => {
+                            params.push(Parameter {
+                                name: s.clone(),
+                                param_type: Type::Int,
+                            });
+                            self.advance();
+                        }
+                        _ => return Err(self.error("Expected parameter name")),
+                    }
+
+                    while matches!(self.current().token_type, TokenType::Comma) {
+                        self.advance();
+                        self.expect(TokenType::Int)?;
+
+                        match &self.current().token_type {
+                            TokenType::Identifier(s) => {
+                                params.push(Parameter {
+                                    name: s.clone(),
+                                    param_type: Type::Int,
+                                });
+                                self.advance();
+                            }
+                            _ => return Err(self.error("Expected parameter name")),
+                        }
+                    }
+                }
+
+                self.expect(TokenType::RParen)?;
+                let body = self.parse_compound_stmt()?;
+
+                Ok(Declaration::Function {
+                    name,
+                    params,
+                    body,
+                    return_type: Type::Int,
+                })
+            }
+            _ => {
+                // Variable declaration
+                let init = if matches!(self.current().token_type, TokenType::Assign) {
+                    self.advance();
+
+                    if let TokenType::Number(n) = self.current().token_type {
+                        self.advance();
+                        Some(ConstExpr::Number(n))
+                    } else {
+                        return Err(self
+                            .error("Expected constant in global variable declaration"));
+                    }
+                } else {
+                    None
+                };
+
+                self.expect(TokenType::Semicolon)?;
+                Ok(Declaration::Variable { name, init })
+            }
+        }
+    }
+
+    fn parse_compound_stmt(&mut self) -> Result<Statement, String> {
+        self.expect(TokenType::LBrace)?;
+        let mut statements = Vec::new();
+
+        while !matches!(self.current().token_type, TokenType::RBrace) {
+            statements.push(self.parse_statement()?);
+        }
+
+        self.expect(TokenType::RBrace)?;
+        Ok(Statement::Compound { statements })
+    }
+
+    fn parse_statement(&mut self) -> Result<Statement, String> {
+        match &self.current().token_type {
+            TokenType::LBrace => Ok(self.parse_compound_stmt()?),
+            TokenType::If => self.parse_if_stmt(),
+            TokenType::While => self.parse_while_stmt(),
+            TokenType::Return => self.parse_return_stmt(),
+            TokenType::Identifier(name) => {
+                let name = name.clone();
+
+                // peek ahead for open paren (func call expr)
+                if matches!(self.peek(1).token_type, TokenType::LParen) {
+                    let expr = self.parse_expression()?; // a function call expr
+                    self.expect(TokenType::Semicolon)?;
+                    return Ok(Statement::Expression { expr });
+                }
+
+                self.advance(); // advance past identifier
+
+                // assignment expression
+                if matches!(self.current().token_type, TokenType::Assign) {
+                    self.advance();
+                    let expr = self.parse_expression()?;
+
+                    self.expect(TokenType::Semicolon)?;
+                    Ok(Statement::Assign {
+                        name,
+                        value: Some(Box::new(expr)),
+                        declare_type: None,
+                    })
+                }
+                // var expression
+                else {
+                    self.expect(TokenType::Semicolon)?;
+                    Ok(Statement::Expression {
+                        expr: Expression::Variable {
+                            name,
+                            expr_type: None,
+                        },
+                    })
+                }
+            }
+            TokenType::Int => {
+                // Local variable declaration
+                self.advance();
+                let name = match &self.current().token_type {
+                    TokenType::Identifier(s) => s.clone(),
+                    _ => return Err(self.error("Expected variable name")),
+                };
+                self.advance();
+
+                let init = if matches!(self.current().token_type, TokenType::Assign) {
+                    self.advance();
+                    Some(self.parse_expression()?)
+                } else {
+                    None
+                };
+
+                self.expect(TokenType::Semicolon)?;
+
+                // Convert to assignment expression statement
+                let expr = if let Some(init_expr) = init {
+                    Statement::Assign {
+                        name,
+                        value: Some(Box::new(init_expr)),
+                        declare_type: Some(Type::Int),
+                    }
+                } else {
+                    Statement::Assign {
+                        name,
+                        value: None,
+                        declare_type: Some(Type::Int),
+                    }
+                };
+
+                Ok(expr)
+            }
+            _ => {
+                let expr = if matches!(self.current().token_type, TokenType::Semicolon) {
+                    Expression::Empty
+                } else {
+                    self.parse_expression()?
+                };
+
+                self.expect(TokenType::Semicolon)?;
+                Ok(Statement::Expression { expr })
+            }
+        }
+    }
+
+    fn parse_if_stmt(&mut self) -> Result<Statement, String> {
+        self.expect(TokenType::If)?;
+        self.expect(TokenType::LParen)?;
+        let condition = self.parse_expression()?;
+        self.expect(TokenType::RParen)?;
+        let then_stmt = Box::new(self.parse_statement()?);
+
+        let else_stmt = if matches!(self.current().token_type, TokenType::Else) {
+            self.advance();
+            Some(Box::new(self.parse_statement()?))
+        } else {
+            None
+        };
+
+        Ok(Statement::If {
+            condition,
+            then_stmt,
+            else_stmt,
+        })
+    }
+
+    fn parse_while_stmt(&mut self) -> Result<Statement, String> {
+        self.expect(TokenType::While)?;
+        self.expect(TokenType::LParen)?;
+        let condition = self.parse_expression()?;
+        self.expect(TokenType::RParen)?;
+        let body = Box::new(self.parse_statement()?);
+
+        Ok(Statement::While { condition, body })
+    }
+
+    fn parse_return_stmt(&mut self) -> Result<Statement, String> {
+        self.expect(TokenType::Return)?;
+
+        let expr = if matches!(self.current().token_type, TokenType::Semicolon) {
+            None
+        } else {
+            Some(self.parse_expression()?)
+        };
+
+        self.expect(TokenType::Semicolon)?;
+        Ok(Statement::Return { expr })
+    }
+
+    fn parse_expression(&mut self) -> Result<Expression, String> {
+        self.parse_comparison()
+    }
+
+    fn parse_comparison(&mut self) -> Result<Expression, String> {
+        let mut expr = self.parse_additive()?;
+
+        while let Some(op) = match &self.current().token_type {
+            TokenType::Eq => Some(BinaryOperator::Eq),
+            TokenType::Ne => Some(BinaryOperator::Ne),
+            TokenType::Lt => Some(BinaryOperator::Lt),
+            TokenType::Gt => Some(BinaryOperator::Gt),
+            TokenType::Le => Some(BinaryOperator::Le),
+            TokenType::Ge => Some(BinaryOperator::Ge),
+            _ => None,
+        } {
+            self.advance();
+            let right = Box::new(self.parse_additive()?);
+            expr = Expression::Binary {
+                op,
+                left: Box::new(expr),
+                right,
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn parse_additive(&mut self) -> Result<Expression, String> {
+        let mut expr = self.parse_multiplicative()?;
+
+        while let Some(op) = match &self.current().token_type {
+            TokenType::Plus => Some(BinaryOperator::Add),
+            TokenType::Minus => Some(BinaryOperator::Sub),
+            _ => None,
+        } {
+            self.advance();
+            let right = Box::new(self.parse_multiplicative()?);
+            expr = Expression::Binary {
+                op,
+                left: Box::new(expr),
+                right,
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn parse_multiplicative(&mut self) -> Result<Expression, String> {
+        let mut expr = self.parse_unary()?;
+
+        while let Some(op) = match &self.current().token_type {
+            TokenType::Star => Some(BinaryOperator::Mul),
+            TokenType::Slash => Some(BinaryOperator::Div),
+            _ => None,
+        } {
+            self.advance();
+            let right = Box::new(self.parse_unary()?);
+            expr = Expression::Binary {
+                op,
+                left: Box::new(expr),
+                right,
+            };
+        }
+
+        Ok(expr)
+    }
+
+    fn parse_unary(&mut self) -> Result<Expression, String> {
+        let op = match &self.current().token_type {
+            TokenType::Plus => Some(UnaryOperator::Plus),
+            TokenType::Minus => Some(UnaryOperator::Minus),
+            _ => None,
+        };
+
+        if let Some(op) = op {
+            self.advance();
+            let operand = Box::new(self.parse_unary()?);
+            return Ok(Expression::Unary { op, operand });
+        }
+
+        self.parse_primary()
+    }
+
+    fn parse_primary(&mut self) -> Result<Expression, String> {
+        match &self.current().token_type.clone() {
+            TokenType::Number(n) => {
+                let value = *n;
+                self.advance();
+                Ok(Expression::Number { value })
+            }
+            TokenType::Identifier(name) => {
+                let name = name.clone();
+                self.advance();
+
+                if matches!(self.current().token_type, TokenType::LParen) {
+                    // Function call
+                    self.advance();
+                    let mut args = Vec::new();
+
+                    if !matches!(self.current().token_type, TokenType::RParen) {
+                        args.push(self.parse_expression()?);
+
+                        while matches!(self.current().token_type, TokenType::Comma) {
+                            self.advance();
+                            args.push(self.parse_expression()?);
+                        }
+                    }
+
+                    self.expect(TokenType::RParen)?;
+                    Ok(Expression::Call { name, args })
+                } else {
+                    Ok(Expression::Variable {
+                        name,
+                        expr_type: None,
+                    })
+                }
+            }
+            TokenType::LParen => {
+                self.advance();
+                let expr = self.parse_expression()?;
+                self.expect(TokenType::RParen)?;
+                Ok(expr)
+            }
+            _ => Err(self.error(&format!(
+                "Unexpected token: {:?}",
+                self.current().token_type
+            ))),
+        }
+    }
+}

common/src/instructions.rs

@@ -3,13 +3,19 @@ use crate::{instructions::encode::Encode, prelude::*};
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum Interrupt {
     Software(u8),
+    Breakpoint,
+    HardFault,
 }
 
 pub type Address = u32;
 
 impl Interrupt {
-    const fn as_u8(self) -> u8 {
+    // someone tell clippy to stfu.
+    #[allow(clippy::must_use_candidate)]
+    pub const fn as_u8(self) -> u8 {
         match self {
+            Self::Breakpoint => 0,
+            Self::HardFault => 1,
             Self::Software(code) => code,
         }
     }
@@ -19,10 +25,11 @@ impl Interrupt {
 impl From<u8> for Interrupt {
     #[allow(unreachable_code)]
     fn from(code: u8) -> Self {
-        return Self::Software(code);
-        todo!("Implement this once a hardware interrupt convention is established.");
-
-        // Self::Software(_code)
+        match code {
+            0 => Self::Breakpoint,
+            1 => Self::HardFault,
+            _ => Self::Software(code),
+        }
     }
 }
 
@@ -73,7 +80,8 @@ pub enum Register {
 }
 
 impl Register {
-    #[must_use]
+    // this is here so clippy shuts up about the must_use tag.
+    #[allow(clippy::must_use_candidate)]
     pub fn general() -> Vec<Self> {
         vec![
             Self::Rg0,

common/src/instructions/encode.rs

@@ -54,12 +54,14 @@ impl Encode for Instruction {
             ],
             no_args: [Nop, IntReturn, Halt],
             special: [
-                Self::Interrupt(_) => todo!(),
                 Self::Data(data) => data,
+                Self::Interrupt(interrupt) => {
+                    let opcode = u32::from(self.opcode());
+                    (opcode << 26) | u32::from(interrupt.as_u8())
+                },
                 Self::Segment(segment) => {
                     let opcode = u32::from(self.opcode());
-                    let segment = segment as u8;
-                    (opcode << 26) | u32::from(segment)
+                    (opcode << 26) | u32::from(segment as u8)
                 }
             ]
         )

compiler/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "compiler"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]

compiler/src/lexer.rs

@@ -0,0 +1,342 @@
+use std::iter::Peekable;
+use std::str::Chars;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Token {
+    // Keywords
+    If,
+    Else,
+    Loop,
+    Break,
+    Return,
+    Continue,
+
+    // Identifiers and literals
+    Identifier(String),
+    String(String),
+    Number(i64),
+
+    // Symbols
+    LeftParen,  // (
+    RightParen, // )
+    LeftBrace,  // {
+    RightBrace, // }
+    Semicolon,  // ;
+    Colon,      // :
+    Comma,      // ,
+    Pipe,       // |
+
+    // Operators
+    Plus,         // +
+    Minus,        // -
+    Star,         // *
+    Slash,        // /
+    Assign,       // =
+    EqualEqual,   // ==
+    Bang,         // !
+    BangEqual,    // !=
+    Less,         // <
+    LessEqual,    // <=
+    Greater,      // >
+    GreaterEqual, // >=
+
+    // Special
+    Eof,
+}
+
+impl Token {
+    pub fn tt(&self) -> &str {
+        match self {
+            Token::If => "If",
+            Token::Else => "Else",
+            Token::Loop => "Loop",
+            Token::Break => "Break",
+            Token::Return => "Return",
+            Token::Continue => "Continue",
+            Token::Identifier(_) => "Identifier",
+            Token::String(_) => "String",
+            Token::Number(_) => "Number",
+            Token::LeftParen => "LeftParen",
+            Token::RightParen => "RightParen",
+            Token::LeftBrace => "LeftBrace",
+            Token::RightBrace => "RightBrace",
+            Token::Semicolon => "Semicolon",
+            Token::Colon => "Colon",
+            Token::Comma => "Comma",
+            Token::Pipe => "Pipe",
+            Token::Plus => "Plus",
+            Token::Minus => "Minus",
+            Token::Star => "Star",
+            Token::Slash => "Slash",
+            Token::Assign => "Assign",
+            Token::EqualEqual => "EqualEqual",
+            Token::Bang => "Bang",
+            Token::BangEqual => "BangEqual",
+            Token::Less => "Less",
+            Token::LessEqual => "LessEqual",
+            Token::Greater => "Greater",
+            Token::GreaterEqual => "GreaterEqual",
+            Token::Eof => "Eof",
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Lexer<'a> {
+    chars: Peekable<Chars<'a>>,
+    current: Option<char>,
+    line: usize,
+}
+
+impl<'a> Lexer<'a> {
+    pub fn new(input: &'a str) -> Self {
+        let mut chars = input.chars().peekable();
+        let current = chars.next();
+
+        Lexer {
+            chars,
+            current,
+            line: 1,
+        }
+    }
+
+    fn advance(&mut self) -> Option<char> {
+        self.current = self.chars.next();
+        self.current
+    }
+
+    fn peek(&mut self) -> Option<&char> {
+        self.chars.peek()
+    }
+
+    fn skip_whitespace(&mut self) {
+        while let Some(c) = self.current {
+            if !c.is_whitespace() {
+                break;
+            }
+            if c == '\n' {
+                self.line += 1;
+            }
+            self.advance();
+        }
+    }
+
+    fn read_identifier(&mut self) -> String {
+        let mut ident = String::new();
+        while let Some(&c) = self.peek() {
+            if c.is_alphanumeric() || c == '_' {
+                ident.push(c);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        ident
+    }
+
+    fn read_number(&mut self) -> i64 {
+        let mut num_str = String::new();
+        while let Some(&c) = self.peek() {
+            if c.is_ascii_digit() {
+                num_str.push(c);
+                self.advance();
+            } else {
+                break;
+            }
+        }
+        num_str.parse().unwrap_or(0)
+    }
+
+    fn match_next(&mut self, expected: char) -> bool {
+        match self.peek() {
+            Some(&c) if c == expected => {
+                self.advance();
+                true
+            }
+            _ => false,
+        }
+    }
+
+    pub fn next_token(&mut self) -> Token {
+        self.skip_whitespace();
+
+        let token = match self.current {
+            Some('(') => Token::LeftParen,
+            Some(')') => Token::RightParen,
+            Some('{') => Token::LeftBrace,
+            Some('}') => Token::RightBrace,
+            Some(';') => Token::Semicolon,
+            Some(':') => Token::Colon,
+            Some(',') => Token::Comma,
+            Some('|') => Token::Pipe,
+            Some('+') => Token::Plus,
+            Some('-') => Token::Minus,
+            Some('*') => Token::Star,
+            Some('/') => Token::Slash,
+            Some('!') => {
+                if self.match_next('=') {
+                    Token::BangEqual
+                } else {
+                    Token::Bang
+                }
+            }
+            Some('=') => {
+                if self.match_next('=') {
+                    Token::EqualEqual
+                } else {
+                    Token::Assign
+                }
+            }
+            Some('<') => {
+                if self.match_next('=') {
+                    Token::LessEqual
+                } else {
+                    Token::Less
+                }
+            }
+            Some('>') => {
+                if self.match_next('=') {
+                    Token::GreaterEqual
+                } else {
+                    Token::Greater
+                }
+            }
+            Some('"') => {
+                self.advance(); // Skip the opening quote
+                let mut s = String::new();
+                while let Some(c) = self.current {
+                    if c == '"' {
+                        break;
+                    }
+                    s.push(c);
+                    self.advance();
+                }
+                Token::String(s)
+            }
+            Some(c) => {
+                if c.is_alphabetic() || c == '_' {
+                    let mut ident = c.to_string();
+                    ident.push_str(&self.read_identifier());
+                    match ident.as_str() {
+                        "if" => Token::If,
+                        "else" => Token::Else,
+                        "loop" => Token::Loop,
+                        "break" => Token::Break,
+                        "return" => Token::Return,
+                        "continue" => Token::Continue,
+                        _ => Token::Identifier(ident),
+                    }
+                } else if c.is_ascii_digit() {
+                    Token::Number(self.read_number())
+                } else {
+                    // Skip unknown characters for now
+                    self.advance();
+                    return self.next_token();
+                }
+            }
+            None => Token::Eof,
+        };
+
+        if token != Token::Eof {
+            self.advance();
+        }
+
+        token
+    }
+}
+
+impl<'a> Iterator for Lexer<'a> {
+    type Item = Token;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.next_token() {
+            Token::Eof => None,
+            token => Some(token),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_keywords() {
+        let input = "if else loop break return continue";
+        let mut lexer = Lexer::new(input);
+
+        assert_eq!(lexer.next_token(), Token::If);
+        assert_eq!(lexer.next_token(), Token::Else);
+        assert_eq!(lexer.next_token(), Token::Loop);
+        assert_eq!(lexer.next_token(), Token::Break);
+        assert_eq!(lexer.next_token(), Token::Return);
+        assert_eq!(lexer.next_token(), Token::Continue);
+        assert_eq!(lexer.next_token(), Token::Eof);
+    }
+
+    #[test]
+    fn test_identifiers_and_numbers() {
+        let input = "x y42 _test 123 45";
+        let mut lexer = Lexer::new(input);
+
+        assert_eq!(lexer.next_token(), Token::Identifier("x".to_string()));
+        assert_eq!(lexer.next_token(), Token::Identifier("y42".to_string()));
+        assert_eq!(lexer.next_token(), Token::Identifier("_test".to_string()));
+        assert_eq!(lexer.next_token(), Token::Number(123));
+        assert_eq!(lexer.next_token(), Token::Number(45));
+        assert_eq!(lexer.next_token(), Token::Eof);
+    }
+
+    #[test]
+    fn test_operators() {
+        let input = "= == ! != < <= > >=";
+        let mut lexer = Lexer::new(input);
+
+        assert_eq!(lexer.next_token(), Token::Assign);
+        assert_eq!(lexer.next_token(), Token::EqualEqual);
+        assert_eq!(lexer.next_token(), Token::Bang);
+        assert_eq!(lexer.next_token(), Token::BangEqual);
+        assert_eq!(lexer.next_token(), Token::Less);
+        assert_eq!(lexer.next_token(), Token::LessEqual);
+        assert_eq!(lexer.next_token(), Token::Greater);
+        assert_eq!(lexer.next_token(), Token::GreaterEqual);
+        assert_eq!(lexer.next_token(), Token::Eof);
+    }
+
+    #[test]
+    fn test_example_syntax() {
+        let input = r#"
+        main: Func = | x: U32, y: U32 | {
+            res = add(x, y);
+            print(res);
+
+            if res > 10 {
+                print("res is greater than 10");
+            }
+        }
+        "#;
+
+        let mut lexer = Lexer::new(input);
+
+        // Skip whitespace and newlines
+        while let Some(c) = lexer.current {
+            if !c.is_whitespace() {
+                break;
+            }
+            lexer.advance();
+        }
+
+        // Test the first few tokens
+        assert_eq!(lexer.next_token(), Token::Identifier("main".to_string()));
+        assert_eq!(lexer.next_token(), Token::Colon);
+        assert_eq!(lexer.next_token(), Token::Identifier("Func".to_string()));
+        assert_eq!(lexer.next_token(), Token::Assign);
+        assert_eq!(lexer.next_token(), Token::Pipe);
+        assert_eq!(lexer.next_token(), Token::Identifier("x".to_string()));
+        assert_eq!(lexer.next_token(), Token::Colon);
+        assert_eq!(lexer.next_token(), Token::Identifier("U32".to_string()));
+        assert_eq!(lexer.next_token(), Token::Comma);
+
+        // The rest of the tokens would be tested similarly
+    }
+}

compiler/src/main.rs

@@ -0,0 +1,25 @@
+use std::{fs, path::Path};
+
+pub mod lexer;
+pub mod parser;
+
+fn main() {
+    println!("Hello, world!");
+
+    let path = Path::new("../resources/dsc/example.dsc");
+    let contents = fs::read_to_string(path).expect("Failed to read file");
+
+    let lexer = lexer::Lexer::new(&contents);
+    let tokens = lexer.collect::<Vec<_>>();
+    println!("{tokens:?}");
+
+    let mut parser = parser::Parser::new(tokens);
+    let ast = match parser.parse() {
+        Ok(ast) => ast,
+        Err(e) => {
+            eprintln!("Error: {e:?}");
+            return;
+        }
+    };
+    println!("{ast:?}");
+}

compiler/src/parser.rs

@@ -0,0 +1,306 @@
+use crate::expect_tt;
+use crate::lexer::Token;
+
+pub struct Parser {
+    ast: Node,
+    idx: usize,
+    tokens: Vec<Token>,
+}
+
+impl Parser {
+    pub fn new(tokens: Vec<Token>) -> Self {
+        Self {
+            ast: Node::Block {
+                children: Vec::new(),
+            },
+            idx: 0,
+            tokens,
+        }
+    }
+
+    pub fn parse(&mut self) -> Result<Node, CompileError> {
+        self.parse_block()
+    }
+
+    fn parse_block(&mut self) -> Result<Node, CompileError> {
+        let mut statements = Vec::new();
+
+        while self.peek_next().is_ok() {
+            statements.push(self.parse_statement()?);
+        }
+
+        Ok(Node::Block {
+            children: statements,
+        })
+    }
+
+    fn parse_statement(&mut self) -> Result<Node, CompileError> {
+        // first token in a statement is always an identifier
+        let left = if let Ok(typed_var) = self.parse_typed_var() {
+            Box::new(typed_var)
+        } else {
+            let tok = expect_tt!(self.next()?, Identifier)?;
+            Box::new(Node::Terminal { value: tok })
+        };
+
+        let _ = expect_tt!(self.next()?, Assign)?;
+
+        let right = Box::new(self.parse_expression()?);
+
+        Ok(Node::Statement { left, right })
+    }
+
+    fn parse_typed_var(&mut self) -> Result<Node, CompileError> {
+        let name = expect_tt!(self.next()?, Identifier)?;
+        let _ = expect_tt!(self.next()?, Colon)?;
+        let type_ = expect_tt!(self.next()?, Identifier)?;
+
+        Ok(Node::TypedVar { name, type_ })
+    }
+
+    fn parse_expression(&mut self) -> Result<Node, CompileError> {
+        if expect_tt!(self.peek_next()?, Pipe).is_ok() {
+            return self.parse_func();
+        }
+
+        if expect_tt!(self.peek_next()?, If).is_ok() {
+            return self.parse_if();
+        }
+
+        if expect_tt!(self.peek_next()?, Loop).is_ok() {
+            return self.parse_loop();
+        }
+
+        if expect_tt!(self.peek_next()?, Identifier, String, Number).is_ok() {
+            let left = Node::Terminal {
+                value: self.next()?,
+            };
+
+            if expect_tt!(
+                self.next()?,
+                Plus,
+                Minus,
+                Star,
+                Slash,
+                EqualEqual,
+                BangEqual,
+                Less,
+                LessEqual,
+                Greater,
+                GreaterEqual
+            )
+            .is_err()
+            {
+                return Ok(left);
+            }
+
+            let operator = self.next()?;
+            let right = Box::new(self.parse_expression()?);
+
+            return Ok(Node::BinaryOp {
+                left: Box::new(left),
+                op: operator,
+                right,
+            });
+        }
+
+        Err(CompileError::Generic)
+    }
+
+    fn parse_func(&mut self) -> Result<Node, CompileError> {
+        // left arg delimiter
+        let _ = expect_tt!(self.next()?, Pipe)?;
+
+        // parse args
+        let mut args = Vec::new();
+
+        while expect_tt!(self.peek_next()?, Identifier).is_ok() {
+            // add a typed var
+            let arg = self.parse_typed_var()?;
+            args.push(arg);
+        }
+
+        // right arg delimiter
+        let _ = expect_tt!(self.next()?, Pipe)?;
+
+        // ensure we have an open brace
+        let _ = expect_tt!(self.next()?, LeftBrace)?;
+
+        // parse the body
+        let body = Box::new(self.parse_block()?);
+
+        // ensure we have a close brace
+        let _ = expect_tt!(self.next()?, RightBrace)?;
+
+        Ok(Node::FunctionDef { params: args, body })
+    }
+
+    fn parse_loop(&mut self) -> Result<Node, CompileError> {
+        let _ = expect_tt!(self.next()?, Loop)?;
+
+        // ensure we have an open brace
+        let _ = expect_tt!(self.next()?, LeftBrace)?;
+
+        // parse the body
+        let body = Box::new(self.parse_block()?);
+
+        // ensure we have a close brace
+        let _ = expect_tt!(self.next()?, RightBrace)?;
+
+        Ok(Node::Loop { body })
+    }
+
+    fn parse_if(&mut self) -> Result<Node, CompileError> {
+        let _ = expect_tt!(self.next()?, If)?;
+
+        // parse condition (expr)
+        let condition = Box::new(self.parse_expression()?);
+
+        // ensure we have an open brace
+        let _ = expect_tt!(self.next()?, LeftBrace)?;
+
+        // parse the "then" branch (expr/statement)
+        let then_branch = Box::new(self.parse_expression()?);
+
+        // ensure we have a close brace
+        let _ = expect_tt!(self.next()?, RightBrace)?;
+
+        // if there is an else branch, we include it in the statement
+        let else_branch = self.parse_else()?.map(Box::new);
+
+        Ok(Node::If {
+            condition,
+            then_branch,
+            else_branch,
+        })
+    }
+
+    fn parse_else(&mut self) -> Result<Option<Node>, CompileError> {
+        // if there is no else branch, return None.
+        if expect_tt!(self.peek_next()?, Else).is_err() {
+            return Ok(None);
+        }
+        let _ = self.next()?;
+
+        if expect_tt!(self.peek_next()?, If).is_ok() {
+            Ok(Some(self.parse_if()?))
+        } else {
+            Ok(Some(self.parse_expression()?))
+        }
+    }
+
+    fn next(&mut self) -> Result<Token, CompileError> {
+        if self.idx >= self.tokens.len() {
+            return Err(CompileError::UnexpectedEOF);
+        }
+
+        let token = self.tokens[self.idx].clone();
+        self.idx += 1;
+
+        Ok(token)
+    }
+
+    fn peek_next(&mut self) -> Result<Token, CompileError> {
+        if self.idx >= self.tokens.len() {
+            return Err(CompileError::UnexpectedEOF);
+        }
+
+        Ok(self.tokens[self.idx].clone())
+    }
+}
+#[derive(Debug, Clone, PartialEq)]
+pub enum Node {
+    /// A scope, which is a list of child nodes that are evaluated in order.
+    Block { children: Vec<Node> },
+
+    /// A leaf node with a value.
+    Terminal { value: Token },
+
+    /// A unary operator with a right operand.
+    UnaryOp { op: Token, right: Box<Node> },
+
+    /// A binary operator with a left and right operand.
+    BinaryOp {
+        left: Box<Node>,
+        op: Token,
+        right: Box<Node>,
+    },
+
+    /// A statement, consisting of a value to assign to, and an expression.
+    Statement { left: Box<Node>, right: Box<Node> },
+
+    /// An if expression, which evaluates to either the then branch or the else branch.
+    If {
+        condition: Box<Node>,
+        then_branch: Box<Node>,
+        else_branch: Option<Box<Node>>,
+    },
+
+    /// A loop expression, which evaluates to the last value of the loop.
+    /// a loop can be exited with the break keyword.
+    Loop { body: Box<Node> },
+
+    /// A function definition. ``` | param: type .. | -> ret_type { body }```
+    FunctionDef { params: Vec<Node>, body: Box<Node> },
+
+    /// A typed variable definition: ```val: Type```
+    TypedVar { name: Token, type_: Token },
+
+    /// A type definition, which is a list of fields. ```type MyType { field: Type }```
+    TypeDef { name: Token, fields: Vec<Node> },
+}
+
+#[derive(Debug)]
+pub enum CompileError {
+    Generic,
+    ExpectedToken { expected: String, found: Token },
+    UnexpectedEOF,
+}
+
+#[macro_export]
+macro_rules! expect_tt {
+    ($token:expr, $($variant:ident),+) => {{
+        let tt = $token.tt().to_string();
+
+        println!("CASE");
+        println!("TOK {:?}", $token);
+        println!("TT {}", tt);
+
+        let mut vs = String::new();
+        $(
+            let s = stringify!($variant);
+            vs.push_str(s);
+            vs.push_str("|");
+        )+
+
+        match tt.as_str() {
+            $(
+                stringify!($variant) => Ok($token.clone()),
+            )+
+            _ => {
+                println!("EXPECTED!! {} [{}]", tt, vs);
+                let expected = format!("[{}]", vec![$(stringify!($variant)),+].join(" | "));
+                Err(CompileError::ExpectedToken {
+                    expected,
+                    found: $token.clone(),
+                })
+            }
+        }
+    }};
+}
+
+#[macro_export]
+macro_rules! expect_value {
+    ($token:expr, $variant:expr) => {{
+        match $token {
+            $variant(x) => Ok(x),
+            _ => {
+                let expected = format!("[{}]")
+                Err(CompileError::ExpectedToken {
+                    expected,
+                    found: $token.clone(),
+                })
+            }
+        }
+    }};
+}

emulator/Cargo.toml

@@ -17,7 +17,6 @@ required-features = ["config"]
 common = { path = "../common" }
 assembler = { path = "../assembler" }
 dsa_editor = { path = "../dsa_editor" }
-eframe = { version = "0.31.1" }
 egui = "0.31.1"
 dirs = "6.0.0"
 discord-presence = { version = "1.6.0", optional = true }
@@ -30,7 +29,7 @@ default = ["config"]
 discord-rpc = ["dep:discord-presence"]
 config = ["dep:toml", "dep:serde"]
 
-# Add support for Android for the fun of it.
+# Add support for Android for the fun of it. Currently crashes lol.
 [target.'cfg(target_os = "android")'.dependencies]
 winit = { version = "0.30.11", features = ["android-native-activity"] }
 # jni = "0.21.1"
@@ -38,3 +37,6 @@ winit = { version = "0.30.11", features = ["android-native-activity"] }
 [target.'cfg(target_os = "android")'.dependencies.eframe]
 version = "0.31.1"
 features = ["android-native-activity"]
+
+[target.'cfg(not(target_os = "android"))'.dependencies.eframe]
+version = "0.31.1"

emulator/src/emulator/system/emulator.rs

@@ -1,15 +1,12 @@
 use std::sync::Arc;
-use std::{
-    sync::mpsc::{self, Receiver, Sender},
-    thread,
-    time::Duration,
-};
+use std::sync::mpsc::{self, Receiver, Sender};
 
 #[allow(unused_imports)]
 use crate::emulator::misc::rpc::{Activity, RpcClient};
 
+use crate::emulator::system::model::StateUpdate;
 use crate::emulator::system::{
-    model::{Command, PersistentState, Running, State},
+    model::{Command, Running},
     processor::Processor,
 };
 
@@ -19,28 +16,33 @@ use common::prelude::*;
 #[allow(unused_variables)]
 pub fn run_emulator(
     cmd_rx: &Receiver<Command>,
-    state_tx: &Sender<State>,
+    state_tx: &Sender<StateUpdate>,
     mut processor: Processor,
     rpc_client: Option<&Arc<RpcClient>>,
 ) {
     println!("INFO: Starting emulator.");
 
     let mut running = Running::Paused;
-    let mut addr = 0u32;
+    let mut step = 0;
+    let mut addr;
     let mut history = Vec::<(u32, Instruction)>::new();
     let size = 256;
 
-    let memory_view = processor.memory.read_range(addr, size);
-    let initial_state = state(&mut processor, running, 0, memory_view, &mut history);
-    let _ = state_tx.send(initial_state);
+    state_tx
+        .send(StateUpdate::Running(Running::Paused))
+        .expect("Failed to send initial state!");
 
     let mut instruction_count = 0;
+    let mut update = false;
 
     loop {
-        let cmd = if running == Running::Running {
+        let cmd = if running == Running::Running || step > 0 {
             match cmd_rx.try_recv() {
                 Ok(cmd) => Some(cmd),
-                Err(mpsc::TryRecvError::Empty) => None,
+                Err(mpsc::TryRecvError::Empty) => {
+                    update = false;
+                    None
+                }
                 Err(mpsc::TryRecvError::Disconnected) => break,
             }
         } else {
@@ -91,7 +93,95 @@ pub fn run_emulator(
 
                     processor.reset();
                 }
-                Command::Step => {
+                Command::Step(x) => {
+                    step = x;
+                }
+                Command::Write(offset, data) => {
+                    update = true;
+
+                    processor
+                        .memory
+                        .write_range(offset, data)
+                        .unwrap_or_else(|_| {
+                            report_err(
+                                state_tx,
+                                "Failed to write memory range!",
+                                &mut processor,
+                            );
+                        });
+                }
+                Command::Interrupt(_interrupt) => {
+                    update = true;
+
+                    todo!("implement interrupts")
+                }
+                Command::MemRequest(new, size) if update => {
+                    addr = new;
+                    let _ = state_tx.send(StateUpdate::MemoryView(
+                        processor.memory.read_range(addr, size).unwrap_or_else(|_| {
+                            report_err(
+                                state_tx,
+                                "Failed to read memory range!",
+                                &mut processor,
+                            );
+                            Vec::new()
+                        }),
+                    ));
+                }
+                Command::DisplayRequest if update => {
+                    let _ = state_tx.send(StateUpdate::DisplayView(
+                        processor.display().unwrap_or_else(|_| {
+                            report_err(
+                                state_tx,
+                                "Failed to read display!",
+                                &mut processor,
+                            );
+                            Vec::new()
+                        }),
+                    ));
+                }
+                Command::StackRequest if update => {
+                    let _ = state_tx.send(StateUpdate::StackView(
+                        processor.get_stack(32).unwrap_or_else(|_| {
+                            report_err(state_tx, "Failed to read stack!", &mut processor);
+                            Vec::new()
+                        }),
+                    ));
+                }
+                Command::RegisterRequest if update => {
+                    let _ = state_tx.send(StateUpdate::Registers(processor.registers));
+                }
+                Command::RunningRequest if update => {
+                    let _ = state_tx.send(StateUpdate::Running(running));
+                }
+                Command::HistoryRequest if update => {
+                    let hsc = history.clone();
+                    history.clear();
+                    let _ = state_tx.send(StateUpdate::InstructionHistory(hsc));
+                }
+                Command::InstructionCountRequest if update => {
+                    let _ = state_tx.send(StateUpdate::Instructions(instruction_count));
+                }
+                Command::WriteBlock(addr, block) => {
+                    processor
+                        .memory
+                        .write_range(addr, block.to_vec())
+                        .unwrap_or_else(|_| {
+                            report_err(
+                                state_tx,
+                                "Failed to write memory block!",
+                                &mut processor,
+                            );
+                        });
+                }
+
+                _ => {}
+            }
+        }
+
+        if step > 0 {
+            step -= 1;
+            update = true;
             running = Running::Paused;
 
             // Execute one cycle.
@@ -100,109 +190,56 @@ pub fn run_emulator(
                     history.push((addr, instruction));
                 }
                 Err(why) => {
-                            let pcx = processor.get(Register::Pcx);
-                            eprintln!(
+                    let pcx = processor
+                        .get(Register::Pcx)
+                        .expect("SPR should never be invalid");
+                    report_err(
+                        state_tx,
+                        &format!(
                             "Could not decode instruction at {pcx:x}. Reason: {why}"
-                            );
-                            continue;
-                        }
-                    }
-
-                    instruction_count += 1;
-                }
-                Command::Read(new, _size) => {
-                    addr = new;
-                }
-                Command::Write(offset, data) => {
-                    processor.memory.write_range(offset, data);
-                }
-                Command::Interrupt(_interrupt) => {
-                    todo!("implement interrupts")
-                }
-            }
-
-            let memory_view = processor.memory.read_range(addr, size);
-            let state = state(
+                        ),
                         &mut processor,
-                running,
-                instruction_count,
-                memory_view,
-                &mut history,
                     );
-
-            println!("state");
-
-            let _ = state_tx.send(state);
+                }
+            }
+            instruction_count += 1;
+            continue;
         }
 
         if running == Running::Running {
-            let mut update = false;
+            update = true;
 
             // Execute one cycle.
             let instruction = match processor.cycle() {
                 Ok(instruction) => instruction,
                 Err(why) => {
-                    let pcx = processor.get(Register::Pcx);
-                    eprintln!("Could not decode instruction at {pcx:x}. Reason: {why}");
-                    continue;
+                    let pcx = processor
+                        .get(Register::Pcx)
+                        .expect("PCX should never be invalid");
+                    report_err(
+                        state_tx,
+                        &format!(
+                            "Could not decode instruction at {pcx:x}. Reason: {why}"
+                        ),
+                        &mut processor,
+                    );
+                    (pcx, Instruction::Nop)
                 }
             };
 
             history.push(instruction);
-
-            // let instruction = match Instruction::decode(cpu_lock.get(Register::Cir))
-            // {};
-
             if matches!(instruction.1, Instruction::Halt) {
                 running = Running::Halted;
-                update = true;
             }
 
             instruction_count += 1;
-
-            // Send state updates every 100 instructions
-            if instruction_count % 100 == 0 {
-                update = true;
-            }
-
-            if update {
-                let memory_view = processor.memory.read_range(addr, size);
-                let state = state(
-                    &mut processor,
-                    running,
-                    instruction_count,
-                    memory_view,
-                    &mut history,
-                );
-                println!("running state");
-                // println!("state!!! {:?}", state.history);
-                let _ = state_tx.send(state);
-            }
-        } else {
-            thread::sleep(Duration::from_millis(1));
         }
     }
 }
 
-fn state(
-    cpu_lock: &mut Processor,
-    running: Running,
-    instruction_count: usize,
-    memory_view: Vec<u8>,
-    history: &mut Vec<(u32, Instruction)>,
-) -> State {
-    let hsclone = history.clone();
-    history.clear();
-
-    State {
-        // TODO: Replace with actual register access from your CPU.
-        reg_file: cpu_lock.registers,
-        running,
-        instructions: instruction_count,
-        stack_view: cpu_lock.get_stack(32),
-        memory_view,
-        display_view: cpu_lock.display(),
-        error: None,
-        persistent: PersistentState { history: hsclone },
-    }
+fn report_err(state_tx: &Sender<StateUpdate>, why: &str, processor: &mut Processor) {
+    processor
+        .begin_interrupt(Interrupt::HardFault)
+        .expect("What kind of goofy ahh shenanigans did you do with your fault handler? At this point, the emulator can just crash. this is on you.");
+    let _ = state_tx.send(StateUpdate::Error(why.to_string()));
 }

emulator/src/emulator/system/memory.rs

@@ -1,13 +1,43 @@
 use std::collections::HashMap;
 
+use crate::emulator::system::model::ProcessorError;
+
 pub trait MemoryUnit: Send + Sync {
     fn reset(&mut self);
-    fn read_byte(&mut self, addr: u32) -> u8;
-    fn write_byte(&mut self, addr: u32, value: u8);
-    fn read_word(&mut self, addr: u32) -> u32;
-    fn write_word(&mut self, addr: u32, value: u32);
-    fn read_range(&mut self, addr: u32, size: u32) -> Vec<u8>;
-    fn write_range(&mut self, addr: u32, value: Vec<u8>);
+    fn read_byte(&mut self, addr: u32) -> Result<u8, ProcessorError>;
+    fn write_byte(&mut self, addr: u32, value: u8) -> Result<(), ProcessorError>;
+    fn read_word(&mut self, addr: u32) -> Result<u32, ProcessorError>;
+    fn write_word(&mut self, addr: u32, value: u32) -> Result<(), ProcessorError>;
+
+    fn read_range(&mut self, addr: u32, size: u32) -> Result<Vec<u8>, ProcessorError> {
+        let mut data = Vec::with_capacity(size as usize);
+        for i in 0..size {
+            data.push(self.read_byte(addr + i)?);
+        }
+        Ok(data)
+    }
+
+    fn write_range(&mut self, addr: u32, value: Vec<u8>) -> Result<(), ProcessorError> {
+        for (i, byte) in value.into_iter().enumerate() {
+            self.write_byte(addr + i as u32, byte)?;
+        }
+        Ok(())
+    }
+
+    fn read_block(&mut self, addr: u32) -> Result<[u8; 256], ProcessorError> {
+        let mut data = [0; 256];
+        for (i, byte) in data.iter_mut().enumerate() {
+            *byte = self.read_byte(addr + i as u32)?;
+        }
+        Ok(data)
+    }
+
+    fn write_block(&mut self, addr: u32, data: [u8; 256]) -> Result<(), ProcessorError> {
+        for (i, byte) in data.iter().enumerate() {
+            self.write_byte(addr + i as u32, *byte)?;
+        }
+        Ok(())
+    }
 }
 
 pub struct MainStore {
@@ -64,59 +94,77 @@ impl MemoryUnit for MainStore {
         self.data.clear();
     }
 
-    fn read_byte(&mut self, addr: u32) -> u8 {
+    fn read_byte(&mut self, addr: u32) -> Result<u8, ProcessorError> {
         let (block_addr, offset) = Self::segment_addr(addr);
         let block = self.block(block_addr);
-        block.data[offset as usize]
+        Ok(block.data[offset as usize])
+    }
+
+    fn read_word(&mut self, addr: u32) -> Result<u32, ProcessorError> {
+        if addr % 4 != 0 {
+            return Err(ProcessorError::BadMemoryAccess(addr));
         }
 
-    fn read_word(&mut self, addr: u32) -> u32 {
         let (block_addr, offset) = Self::segment_addr(addr);
-
-        println!("reading word from {block_addr:x?} + {offset}");
-
         let block = self.mut_block(block_addr);
         let mut bytes = [0; 4];
         bytes[0] = block.data[offset as usize];
         bytes[1] = block.data[(offset + 1) as usize];
         bytes[2] = block.data[(offset + 2) as usize];
         bytes[3] = block.data[(offset + 3) as usize];
-        u32::from_be_bytes(bytes)
+        Ok(u32::from_be_bytes(bytes))
     }
 
-    fn read_range(&mut self, addr: u32, size: u32) -> Vec<u8> {
+    fn read_range(&mut self, addr: u32, size: u32) -> Result<Vec<u8>, ProcessorError> {
         let mut data = Vec::with_capacity(size as usize);
         for i in 0..size {
-            data.push(self.read_byte(addr + i));
+            data.push(self.read_byte(addr + i)?);
         }
 
-        // println!("reading {data:?} from {addr:x?}");
-
-        data
+        Ok(data)
     }
 
-    fn write_byte(&mut self, addr: u32, value: u8) {
+    fn write_byte(&mut self, addr: u32, value: u8) -> Result<(), ProcessorError> {
         let (block_addr, offset) = Self::segment_addr(addr);
         let block = self.mut_block(block_addr);
         block.data[offset as usize] = value;
+        Ok(())
+    }
+
+    fn write_word(&mut self, addr: u32, value: u32) -> Result<(), ProcessorError> {
+        if addr % 4 != 0 {
+            return Err(ProcessorError::BadMemoryAccess(addr));
         }
 
-    fn write_word(&mut self, addr: u32, value: u32) {
         let (block_addr, offset) = Self::segment_addr(addr);
         let block = self.mut_block(block_addr);
         block.data[offset as usize] = (value >> 24) as u8;
         block.data[(offset + 1) as usize] = (value >> 16) as u8;
         block.data[(offset + 2) as usize] = (value >> 8) as u8;
         block.data[(offset + 3) as usize] = value as u8;
+        Ok(())
     }
 
-    fn write_range(&mut self, addr: u32, value: Vec<u8>) {
-        // println!("writing {value:?} to {addr:x?}");
-
+    fn write_range(&mut self, addr: u32, value: Vec<u8>) -> Result<(), ProcessorError> {
         for (i, byte) in value.into_iter().enumerate() {
             let (block_addr, offset) = Self::segment_addr(addr + i as u32);
             let block = self.mut_block(block_addr);
             block.data[offset as usize] = byte;
         }
+
+        Ok(())
+    }
+
+    fn read_block(&mut self, addr: u32) -> Result<[u8; 256], ProcessorError> {
+        let (block_addr, _) = Self::segment_addr(addr);
+        let block = self.block(block_addr);
+        Ok(block.data)
+    }
+
+    fn write_block(&mut self, addr: u32, data: [u8; 256]) -> Result<(), ProcessorError> {
+        let (block_addr, _) = Self::segment_addr(addr);
+        let block = self.mut_block(block_addr);
+        block.data = data;
+        Ok(())
     }
 }

emulator/src/emulator/system/model.rs

@@ -1,3 +1,5 @@
+use std::sync::mpsc::{self, Receiver, Sender};
+
 use common::prelude::*;
 
 #[derive(PartialEq, Eq, Debug, Clone, Copy)]
@@ -16,15 +18,143 @@ pub trait IODevice: Send + Sync {
 
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub enum Command {
+    // set emulator state.
     Start,
     Stop,
-    Step,
+    Step(usize),
     Reset(usize),
     Interrupt(Interrupt),
-
-    // Performs direct read/write operations on the emulator's memory.
-    Read(Address, u32),
     Write(Address, Vec<u8>),
+    WriteBlock(Address, Box<[u8; 256]>),
+
+    // request emulator state.
+    MemRequest(Address, u32),
+    DisplayRequest,
+    StackRequest,
+    RegisterRequest,
+    RunningRequest,
+    HistoryRequest,
+    InstructionCountRequest,
+}
+
+#[derive(Debug)]
+pub enum ProcessorError {
+    InvalidInstruction(u32),
+    InvalidRegister(u8),
+    BadMemoryAccess(u32),
+}
+
+impl std::error::Error for ProcessorError {}
+
+impl std::fmt::Display for ProcessorError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidInstruction(instruction) => {
+                write!(f, "Invalid instruction: {instruction}")
+            }
+            Self::InvalidRegister(register) => {
+                write!(f, "Invalid register: {register}")
+            }
+            Self::BadMemoryAccess(address) => {
+                write!(f, "Bad memory access: {address}")
+            }
+        }
+    }
+}
+
+pub struct State {
+    pub state_receiver: Receiver<StateUpdate>,
+    pub cmd_sender: Sender<Command>,
+
+    // Processor state
+    pub reg_file: RegFile,
+    pub running: Running,
+    pub instructions: usize,
+
+    // Memory access views
+    pub stack_view: Vec<u8>,
+    pub memory_view: Vec<u8>,
+    pub display_view: Vec<u8>,
+
+    pub error_log: Vec<String>,
+
+    pub instruction_history: Vec<(u32, Instruction)>,
+}
+
+impl State {
+    #[must_use]
+    pub fn new(sender: Sender<Command>, receiver: Receiver<StateUpdate>) -> Self {
+        Self {
+            state_receiver: receiver,
+            cmd_sender: sender,
+            reg_file: RegFile::default(),
+            running: Running::Paused,
+            instructions: 0,
+            stack_view: vec![],
+            memory_view: vec![],
+            display_view: vec![],
+            error_log: vec![],
+            instruction_history: vec![],
+        }
+    }
+
+    pub fn send(&mut self, cmd: Command) {
+        if let Err(e) = self.cmd_sender.send(cmd) {
+            self.error_log.push(e.to_string());
+        }
+    }
+
+    pub fn update(&mut self) -> Result<(), mpsc::TryRecvError> {
+        while let Ok(update) = self.state_receiver.try_recv() {
+            match update {
+                StateUpdate::Registers(reg_file) => self.reg_file = reg_file,
+                StateUpdate::Running(running) => self.running = running,
+                StateUpdate::Instructions(instructions) => {
+                    self.instructions = instructions;
+                }
+                StateUpdate::StackView(stack_view) => self.stack_view = stack_view,
+                StateUpdate::MemoryView(memory_view) => self.memory_view = memory_view,
+                StateUpdate::DisplayView(display_view) => {
+                    self.display_view = display_view;
+                }
+                StateUpdate::Error(err_state) => self.error_log.push(err_state),
+                StateUpdate::InstructionHistory(history) => {
+                    self.instruction_history.extend(history);
+                }
+            }
+
+            if self.error_log.len() > 256 {
+                self.error_log.drain(0..self.error_log.len() - 256);
+            }
+
+            if self.instruction_history.len() > 1024 {
+                self.instruction_history
+                    .drain(0..self.instruction_history.len() - 1024);
+            }
+        }
+
+        if let Err(e) = self.state_receiver.try_recv() {
+            match e {
+                mpsc::TryRecvError::Empty => {}
+                mpsc::TryRecvError::Disconnected => {
+                    return Err(e);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+pub enum StateUpdate {
+    Registers(RegFile),
+    Running(Running),
+    Instructions(usize),
+    StackView(Vec<u8>),
+    MemoryView(Vec<u8>),
+    DisplayView(Vec<u8>),
+    Error(String),
+    InstructionHistory(Vec<(u32, Instruction)>),
 }
 
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
@@ -127,8 +257,8 @@ impl RegFile {
         self.pcx = 0;
     }
 
-    pub fn reg(&mut self, reg: Register) -> &mut u32 {
-        match reg {
+    pub const fn reg(&mut self, reg: Register) -> Result<&mut u32, ProcessorError> {
+        Ok(match reg {
             Register::Rg0 => &mut self.rg0,
             Register::Rg1 => &mut self.rg1,
             Register::Rg2 => &mut self.rg2,
@@ -156,13 +286,13 @@ impl RegFile {
             Register::Sts => &mut self.sts,
             Register::Cir => &mut self.cir,
             Register::Pcx => &mut self.pcx,
-            _ => panic!("Invalid register."),
-        }
+            _ => return Err(ProcessorError::InvalidRegister(Register::NoReg as u8)),
+        })
     }
 
     #[must_use]
-    pub fn get(&self, reg: Register) -> u32 {
-        match reg {
+    pub const fn get(&self, reg: Register) -> Result<u32, ProcessorError> {
+        Ok(match reg {
             Register::Rg0 => self.rg0,
             Register::Rg1 => self.rg1,
             Register::Rg2 => self.rg2,
@@ -191,51 +321,7 @@ impl RegFile {
             Register::Cir => self.cir,
             Register::Pcx => self.pcx,
             Register::Zero => 0,
-            _ => panic!("Invalid register."),
-        }
-    }
-}
-
-pub struct State {
-    pub reg_file: RegFile,
-    pub running: Running,
-    pub instructions: usize,
-
-    // Memory access views
-    pub stack_view: Vec<u8>,
-    pub memory_view: Vec<u8>,
-    pub display_view: Vec<u8>,
-    pub error: Option<String>,
-
-    pub persistent: PersistentState,
-}
-
-impl Default for State {
-    fn default() -> Self {
-        Self {
-            reg_file: RegFile::default(),
-            running: Running::Paused,
-            instructions: 0,
-            stack_view: vec![],
-            memory_view: vec![],
-            display_view: vec![],
-            persistent: PersistentState::default(),
-            error: None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct PersistentState {
-    pub history: Vec<(u32, Instruction)>,
-}
-
-impl PersistentState {
-    pub fn update(&mut self, new_state: &Self) {
-        self.history.extend(new_state.history.clone());
-        if self.history.len() > 1024 {
-            let len = self.history.len() - 1024;
-            self.history.drain(..len);
-        }
+            _ => return Err(ProcessorError::InvalidRegister(Register::NoReg as u8)),
+        })
     }
 }

emulator/src/emulator/system/processor/mod.rs

@@ -5,12 +5,10 @@ use std::{
 
 use crate::emulator::system::{
     memory::MemoryUnit,
-    model::{IODevice, RegFile},
+    model::{IODevice, ProcessorError, RegFile},
 };
 
-use common::instructions::{
-    Instruction, Interrupt, Register, errors::InstructionDecodeError,
-};
+use common::instructions::{Instruction, Interrupt, Register};
 
 pub struct Processor {
     pub memory: Box<dyn MemoryUnit>,
@@ -18,14 +16,13 @@ pub struct Processor {
     pub halted: bool,
     pub io_devices: Vec<Arc<dyn IODevice>>,
 
-    pub dustbin: u32,
+    pub void: u32,
 }
 
 fn log(message: &str) {
     println!("\x1b[32mINFO:\x1b[0m {message}");
 }
 
-#[allow(clippy::needless_pass_by_ref_mut)]
 impl Processor {
     #[must_use]
     pub fn new(memory: Box<dyn MemoryUnit>, io_devices: Vec<Arc<dyn IODevice>>) -> Self {
@@ -34,7 +31,7 @@ impl Processor {
             registers: RegFile::default(),
             halted: false,
             io_devices,
-            dustbin: 0,
+            void: 0,
         }
     }
 
@@ -48,48 +45,45 @@ impl Processor {
         self.memory.reset();
     }
 
-    pub fn cycle(&mut self) -> Result<(u32, Instruction), InstructionDecodeError> {
+    pub fn cycle(&mut self) -> Result<(u32, Instruction), ProcessorError> {
         self.halted = false;
 
         // Get value from PCX.
-        let addr = self.fetch();
+        let addr = self.fetch()?;
         // Increment PCX.
         self.advance();
 
         // Set MAR to the previous value of PCX.
-        *self.reg(Register::Mar) = addr;
-        let val = self.memory.read_word(addr);
+        *self.reg(Register::Mar)? = addr;
+        let val = self.memory.read_word(addr)?;
 
         // Set CIR to the value of RAM[MAR].
-        *self.reg(Register::Mar) = val;
+        *self.reg(Register::Mar)? = val;
 
         // Decode and execute the instruction.
-        let instruction = Instruction::decode(val)?;
-
-        log(&instruction.to_string());
-
-        instruction.execute(self);
+        let instruction = Instruction::decode(val)
+            .map_err(|_| ProcessorError::InvalidInstruction(val))?;
 
+        instruction.execute(self)?;
         Ok((addr, instruction))
     }
 
-    fn fetch(&self) -> u32 {
+    const fn fetch(&self) -> Result<u32, ProcessorError> {
         self.get(Register::Pcx)
     }
 
-    #[must_use]
-    pub fn get(&self, reg: Register) -> u32 {
+    pub const fn get(&self, reg: Register) -> Result<u32, ProcessorError> {
         self.registers.get(reg)
     }
 
-    pub fn reg(&mut self, reg: Register) -> &mut u32 {
+    pub const fn reg(&mut self, reg: Register) -> Result<&mut u32, ProcessorError> {
         match reg {
-            Register::Zero => &mut self.dustbin,
+            Register::Zero => Ok(&mut self.void),
             _ => self.registers.reg(reg),
         }
     }
 
-    pub fn display(&mut self) -> Vec<u8> {
+    pub fn display(&mut self) -> Result<Vec<u8>, ProcessorError> {
         self.memory.read_range(0x20000, 2000)
     }
 
@@ -99,53 +93,74 @@ impl Processor {
         self.set_flag(Flag::LessThan, a < b);
     }
 
-    // stack operations
-
-    pub fn push(&mut self, value: u32) {
-        let stack_ptr = self.get(Register::Spr);
-        *self.reg(Register::Spr) += 4;
-        self.memory.write_word(stack_ptr, value);
-    }
-
-    pub fn pop(&mut self) -> u32 {
-        *self.reg(Register::Spr) -= 4;
-        self.memory.read_word(self.get(Register::Spr))
-    }
-
     // functions to set new state
-
     fn set_flag(&mut self, flag: Flag, value: bool) {
         if value {
-            *self.reg(Register::Sts) |= flag as u32;
+            *self
+                .reg(Register::Sts)
+                .expect("STS should never be invalid") |= flag as u32;
         } else {
-            *self.reg(Register::Sts) &= !(flag as u32);
+            *self
+                .reg(Register::Sts)
+                .expect("STS should never be invalid") &= !(flag as u32);
         }
     }
 
-    fn get_flag(&self, flag: Flag) -> bool {
-        self.get(Register::Sts) & (flag as u32) != 0
+    fn get_flag(&self, flag: Flag) -> Result<bool, ProcessorError> {
+        Ok(self.get(Register::Sts)? & (flag as u32) != 0)
     }
 
-    fn advance(&mut self) {
+    fn advance(&mut self) -> Result<(), ProcessorError> {
         // increment PCX
-        *self.reg(Register::Pcx) += 4;
+        *self.reg(Register::Pcx)? += 4;
+        Ok(())
     }
 
-    fn jump(&mut self, reg: Register, offset: u16) {
-        *self.reg(Register::Pcx) = self.get(reg) + u32::from(offset);
+    fn jump(&mut self, reg: Register, offset: u16) -> Result<(), ProcessorError> {
+        *self.reg(Register::Pcx)? = self.get(reg)? + u32::from(offset);
+        Ok(())
     }
 
-    fn begin_interrupt(&mut self, _int: Interrupt) {
-        // first we get the address of the interrupt descriptor table.
-        todo!();
+    pub fn begin_interrupt(
+        &mut self,
+        interrupt: Interrupt,
+    ) -> Result<(), ProcessorError> {
+        let idt = self.get(Register::Idr)?;
+
+        let addr = self
+            .memory
+            .read_word(idt + u32::from(interrupt.as_u8()) * 4)?;
+        println!("INFO: Interrupt {interrupt:?} addr: {addr}");
+
+        self.push(self.get(Register::Pcx)?)?;
+        *self.reg(Register::Pcx)? = addr;
+        Ok(())
     }
 
-    fn end_interrupt(&mut self) {
-        todo!();
+    fn push(&mut self, val: u32) -> Result<(), ProcessorError> {
+        *self.reg(Register::Spr)? -= 4;
+        let reg = *self.reg(Register::Spr)?;
+        self.memory.write_word(reg, val)
     }
 
-    pub fn get_stack(&mut self, n: u32) -> Vec<u8> {
-        let addr = self.get(Register::Spr);
+    fn pop(&mut self) -> Result<u32, ProcessorError> {
+        let reg = *self.reg(Register::Spr)?;
+        let val = self.memory.read_word(reg)?;
+        *self.reg(Register::Spr)? += 4;
+        Ok(val)
+    }
+
+    // TODO: remove this once implemented
+    #[allow(clippy::needless_pass_by_ref_mut)]
+    fn end_interrupt(&mut self) -> Result<(), ProcessorError> {
+        let ret = self.pop()?;
+        *self.reg(Register::Ret)? = ret;
+        *self.reg(Register::Pcx)? = ret;
+        Ok(())
+    }
+
+    pub fn get_stack(&mut self, n: u32) -> Result<Vec<u8>, ProcessorError> {
+        let addr = self.get(Register::Spr)?;
         let size = n * 4;
         // returns the stack
         self.memory.read_range(
@@ -170,38 +185,40 @@ enum Flag {
 }
 
 trait Executable {
-    fn execute(self, cpu: &mut Processor);
+    fn execute(self, cpu: &mut Processor) -> Result<(), ProcessorError>;
 }
 
 impl Executable for Instruction {
     #[allow(clippy::too_many_lines)]
-    fn execute(self, cpu: &mut Processor) {
+    fn execute(self, cpu: &mut Processor) -> Result<(), ProcessorError> {
         match self {
             // No operation - a blank line.
             // Copies from SrcReg to a.drReg.
             Self::Mov(a) => {
-                *cpu.reg(a.dr) = cpu.get(a.sr1);
+                *cpu.reg(a.dr)? = cpu.get(a.sr1)?;
             }
 
             // Copies from SrcReg to a.drReg, sign extending the value to take up a full
             // word.
             Self::MovSigned(a) => {
-                *cpu.reg(a.dr) = sign_extend(cpu.get(a.sr1));
+                *cpu.reg(a.dr)? = sign_extend(cpu.get(a.sr1)?);
             }
 
             // Loads a byte from memory address (base + offset) into a.drReg. The
             // effective address must be byte-aligned.
             Self::LoadByte(a) => {
-                *cpu.reg(a.r2) = u32::from(
-                    cpu.memory.read_byte(cpu.get(a.r1) + u32::from(a.immediate)),
+                *cpu.reg(a.r2)? = u32::from(
+                    cpu.memory
+                        .read_byte(cpu.get(a.r1)? + u32::from(a.immediate))?,
                 );
             }
 
             // Loads a sign-extended byte from memory address (base + offset) into
             // a.drReg. The effective address must be byte-aligned.
             Self::LoadByteSigned(a) => {
-                *cpu.reg(a.r2) = sign_extend(u32::from(
-                    cpu.memory.read_byte(cpu.get(a.r1) + u32::from(a.immediate)),
+                *cpu.reg(a.r2)? = sign_extend(u32::from(
+                    cpu.memory
+                        .read_byte(cpu.get(a.r1)? + u32::from(a.immediate))?,
                 ));
             }
 
@@ -210,181 +227,184 @@ impl Executable for Instruction {
             Self::LoadHalfword(a) => {
                 // we read an entire word, then right shift so we only get the first half
                 // of the word
-                *cpu.reg(a.r2) =
-                    cpu.memory.read_word(cpu.get(a.r1) + u32::from(a.immediate)) >> 16;
+                *cpu.reg(a.r2)? = cpu
+                    .memory
+                    .read_word(cpu.get(a.r1)? + u32::from(a.immediate))?
+                    >> 16;
             }
 
             // Loads a sign-extended half-word from memory address (base + offset) into
             // a.drReg. The effective address must be 2-byte-aligned.
             Self::LoadHalfwordSigned(a) => {
-                *cpu.reg(a.r2) = sign_extend(
-                    cpu.memory.read_word(cpu.get(a.r1) + u32::from(a.immediate)) >> 16,
+                *cpu.reg(a.r2)? = sign_extend(
+                    cpu.memory
+                        .read_word(cpu.get(a.r1)? + u32::from(a.immediate))?
+                        >> 16,
                 );
             }
 
             // Loads a word from memory address (base + offset) into a.drReg. The
             // effective address must be 4-byte-aligned.
             Self::LoadWord(a) => {
-                *cpu.reg(a.r2) =
-                    cpu.memory.read_word(cpu.get(a.r1) + u32::from(a.immediate));
+                *cpu.reg(a.r2)? = cpu
+                    .memory
+                    .read_word(cpu.get(a.r1)? + u32::from(a.immediate))?;
             }
 
             // Stores a byte from SrcReg in memory address (base + offset) The effective
             // address must be byte-aligned.
             Self::StoreByte(a) => {
                 cpu.memory.write_byte(
-                    cpu.get(a.r2) + u32::from(a.immediate),
-                    cpu.get(a.r1) as u8,
-                );
+                    cpu.get(a.r2)? + u32::from(a.immediate),
+                    cpu.get(a.r1)? as u8,
+                )?;
             }
 
             // Stores a half-word from SrcReg in memory address (base + offset) The
             // effective address must be 2-byte-aligned.
             Self::StoreHalfword(a) => {
                 // split the value into bytes and then write two bytes
-                let bytes = (cpu.get(a.r1) as u16).to_le_bytes();
+                let bytes = (cpu.get(a.r1)? as u16).to_le_bytes();
                 cpu.memory
-                    .write_byte(cpu.get(a.r2) + u32::from(a.immediate), bytes[0]);
+                    .write_byte(cpu.get(a.r2)? + u32::from(a.immediate), bytes[0])?;
                 cpu.memory
-                    .write_byte(cpu.get(a.r2) + u32::from(a.immediate) + 1, bytes[1]);
+                    .write_byte(cpu.get(a.r2)? + u32::from(a.immediate) + 1, bytes[1])?;
             }
 
             // Stores a word from SrcReg in memory address (base + offset) The effective
             // address must be 4-byte-aligned.
             Self::StoreWord(a) => {
-                cpu.memory
-                    .write_word(cpu.get(a.r2) + u32::from(a.immediate), cpu.get(a.r1));
+                cpu.memory.write_word(
+                    cpu.get(a.r2)? + u32::from(a.immediate),
+                    cpu.get(a.r1)?,
+                )?;
             }
 
             // Loads a 16-bit literal value into reg, setting the bottom 16 bits of the
             // word. To populate the upper 16 bits, see LUI.
             Self::LoadLowerImmediate(a) => {
-                *cpu.reg(a.r1) = u32::from(a.immediate);
+                *cpu.reg(a.r1)? = u32::from(a.immediate);
             }
 
             // Loads a 16-bit literal value into reg, setting the top 16 bits of the word.
             // To populate the lower 16 bits, see LLI.
             Self::LoadUpperImmediate(a) => {
-                *cpu.reg(a.r1) =
-                    (cpu.get(a.r1) & 0x0000_FFFF) | (u32::from(a.immediate) << 16);
+                *cpu.reg(a.r1)? =
+                    (cpu.get(a.r1)? & 0x0000_FFFF) | (u32::from(a.immediate) << 16);
             }
 
             // Unconditionally jumps to the calculated address or direct address
-            Self::Jump(a) => cpu.jump(a.r1, a.immediate),
+            Self::Jump(a) => cpu.jump(a.r1, a.immediate)?,
 
             // Jumps to the calculated address or direct address if equal flag set.
             Self::JumpEq(a) => {
-                if cpu.get_flag(Flag::Equal) {
-                    cpu.jump(a.r1, a.immediate);
+                if cpu.get_flag(Flag::Equal)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Jumps to the calculated address or direct address if equal flag not set.
             Self::JumpNeq(a) => {
-                if !cpu.get_flag(Flag::Equal) {
-                    cpu.jump(a.r1, a.immediate);
+                if !cpu.get_flag(Flag::Equal)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Jumps to the calculated address or direct address if greater than flag set.
             Self::JumpGt(a) => {
-                if cpu.get_flag(Flag::GreaterThan) {
-                    cpu.jump(a.r1, a.immediate);
+                if cpu.get_flag(Flag::GreaterThan)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Jumps to the calculated address or direct address if greater than flag or
             // equal flag set.
             Self::JumpGe(a) => {
-                if cpu.get_flag(Flag::GreaterThan) || cpu.get_flag(Flag::Equal) {
-                    cpu.jump(a.r1, a.immediate);
+                if cpu.get_flag(Flag::GreaterThan)? || cpu.get_flag(Flag::Equal)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Jumps to the calculated address or direct address if less than flag set.
             Self::JumpLt(a) => {
-                if cpu.get_flag(Flag::LessThan) {
-                    cpu.jump(a.r1, a.immediate);
+                if cpu.get_flag(Flag::LessThan)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Jumps to the calculated address or direct address if less than flag or
             // equal flag set.
             Self::JumpLe(a) => {
-                if cpu.get_flag(Flag::LessThan) || cpu.get_flag(Flag::Equal) {
-                    cpu.jump(a.r1, a.immediate);
+                if cpu.get_flag(Flag::LessThan)? || cpu.get_flag(Flag::Equal)? {
+                    cpu.jump(a.r1, a.immediate)?;
                 }
             }
 
             // Increments the value in the given register
-            Self::Increment(a) => *cpu.reg(a.sr1) = inc(cpu.get(a.sr1)),
+            Self::Increment(a) => *cpu.reg(a.sr1)? = inc(cpu.get(a.sr1)?),
 
             // Decrements the value in the given register
-            Self::Decrement(a) => *cpu.reg(a.sr1) = dec(cpu.get(a.sr1)),
+            Self::Decrement(a) => *cpu.reg(a.sr1)? = dec(cpu.get(a.sr1)?),
 
             // Left shifts the value in Reg by the given amount (either a register, or a
             // literal value)
             Self::ShiftLeft(a) => {
-                let regval = cpu.get(a.sr2);
-                let val = cpu.get(a.sr1);
-
-                *cpu.reg(a.sr1) =
-                    shl(val, if regval != 0 { regval as u8 } else { a.shamt });
+                let reg = cpu.get(a.sr1)?;
+                let val = a.shamt;
+                *cpu.reg(a.sr1)? = shl(reg, val);
             }
 
             // Right shifts the value in Reg by the given amount (either a register, or a
             // literal value).
             Self::ShiftRight(a) => {
-                let regval = cpu.get(a.sr2);
-                let val = cpu.get(a.sr1);
-
-                *cpu.reg(a.sr1) =
-                    shr(val, if regval != 0 { regval as u8 } else { a.shamt });
+                let regval = cpu.get(a.sr1)?;
+                let val = a.shamt;
+                *cpu.reg(a.sr1)? = shr(regval, val);
             }
 
             // Adds the value of Src2 to Src1 and writes the result to a.dr
             Self::Add(a) => {
-                *cpu.reg(a.dr) = add(cpu.get(a.sr1), cpu.get(a.sr2));
+                *cpu.reg(a.dr)? = add(cpu.get(a.sr1)?, cpu.get(a.sr2)?);
             }
 
             // Subtracts the value of Src2 from Src1 and writes the result to a.dr
             Self::Sub(a) => {
-                *cpu.reg(a.dr) = sub(cpu.get(a.sr1), cpu.get(a.sr2));
+                *cpu.reg(a.dr)? = sub(cpu.get(a.sr1)?, cpu.get(a.sr2)?);
             }
 
             Self::AddImmediate(a) => {
-                *cpu.reg(a.r2) = add(cpu.get(a.r1), u32::from(a.immediate));
+                *cpu.reg(a.r2)? = add(cpu.get(a.r1)?, u32::from(a.immediate));
             }
 
             Self::SubImmediate(a) => {
-                *cpu.reg(a.r2) = sub(cpu.get(a.r1), u32::from(a.immediate));
+                *cpu.reg(a.r2)? = sub(cpu.get(a.r1)?, u32::from(a.immediate));
             }
 
             // Performs bitwise AND on Src1 and Src2 storing the result in a.dr
-            Self::And(a) => *cpu.reg(a.dr) = and(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::And(a) => *cpu.reg(a.dr)? = and(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Performs bitwise OR on Src1 and Src2 storing the result in a.dr
-            Self::Or(a) => *cpu.reg(a.dr) = or(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::Or(a) => *cpu.reg(a.dr)? = or(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Performs bitwise NOT on Src storing the result in a.dr
-            Self::Not(a) => *cpu.reg(a.dr) = not(cpu.get(a.sr1)),
+            Self::Not(a) => *cpu.reg(a.dr)? = not(cpu.get(a.sr1)?),
 
             // Performs bitwise XOR on Src1 and Src2 storing the result in a.dr
-            Self::Xor(a) => *cpu.reg(a.dr) = xor(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::Xor(a) => *cpu.reg(a.dr)? = xor(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Performs bitwise NAND on Src1 and Src2 storing the result in a.dr
-            Self::Nand(a) => *cpu.reg(a.dr) = nand(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::Nand(a) => *cpu.reg(a.dr)? = nand(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Performs bitwise NOR on Src1 and Src2 storing the result in a.dr
-            Self::Nor(a) => *cpu.reg(a.dr) = nor(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::Nor(a) => *cpu.reg(a.dr)? = nor(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Performs bitwise XNOR on Src1 and Src2 storing the result in a.dr
-            Self::Xnor(a) => *cpu.reg(a.dr) = xnor(cpu.get(a.sr1), cpu.get(a.sr2)),
+            Self::Xnor(a) => *cpu.reg(a.dr)? = xnor(cpu.get(a.sr1)?, cpu.get(a.sr2)?),
 
             // Compares the value of Reg1 to the value in Reg2. The results of the
             // comparisons are set in the Status register.
             Self::Compare(a) => {
-                cpu.cmp(cpu.get(a.sr1), cpu.get(a.sr2));
+                cpu.cmp(cpu.get(a.sr1)?, cpu.get(a.sr2)?);
             }
 
             // Initiates an interrupt with the given 8 bit interrupt code.
@@ -392,12 +412,12 @@ impl Executable for Instruction {
             //      - The return address is saved to the RET register.
             //      - The stack base ptr is set to the kernel stack.
             Self::Interrupt(interrupt_code) => {
-                cpu.begin_interrupt(interrupt_code);
+                cpu.begin_interrupt(interrupt_code)?;
             }
 
             // Returns from an interrupt,
             Self::IntReturn => {
-                cpu.end_interrupt();
+                cpu.end_interrupt()?;
             }
 
             // Halts the processor.
@@ -411,6 +431,7 @@ impl Executable for Instruction {
                 todo!()
             }
         }
+        Ok(())
     }
 }
 

emulator/src/emulator/system/processor/tests.rs

@@ -13,22 +13,32 @@ fn test_nop_instruction() {
     let mut cpu = create_test_processor();
     let initial_state = cpu.registers;
 
-    Instruction::Nop.execute(&mut cpu);
+    Instruction::Nop.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
 
     assert_eq!(
-        cpu.registers.get(Register::Rg0),
-        initial_state.get(Register::Rg0)
+        cpu.registers
+            .get(Register::Rg0)
+            .expect("Failed to get register Rg0"),
+        initial_state
+            .get(Register::Rg0)
+            .expect("Failed to get register Rg0")
     );
     assert_eq!(
-        cpu.registers.get(Register::Acc),
-        initial_state.get(Register::Acc)
+        cpu.registers
+            .get(Register::Acc)
+            .expect("Failed to get register Acc"),
+        initial_state
+            .get(Register::Acc)
+            .expect("Failed to get register Acc")
     );
 }
 
 #[test]
 fn test_mov_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0x1234_5678;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x1234_5678;
 
     let mov_instr = Instruction::Mov(RTypeArgs::new(
         Some(Register::Rg1),
@@ -37,14 +47,19 @@ fn test_mov_instruction() {
         None,
     ));
 
-    mov_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0x1234_5678);
+    mov_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0x1234_5678
+    );
 }
 
 #[test]
 fn test_mov_signed_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0x0000_00FF;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x0000_00FF;
 
     let mov_signed_instr = Instruction::MovSigned(RTypeArgs::new(
         Some(Register::Rg1),
@@ -53,16 +68,23 @@ fn test_mov_signed_instruction() {
         None,
     ));
 
-    mov_signed_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0xFFFF_FFFF);
+    mov_signed_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0xFFFF_FFFF
+    );
 }
 
 #[test]
 fn test_load_byte_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    cpu.memory.write_byte(addr, 0xAB);
-    *cpu.reg(Register::Rg1) = addr - 4;
+    cpu.memory
+        .write_byte(addr, 0xAB)
+        .expect("Failed to write byte to memory");
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr - 4;
 
     let load_byte_instr = Instruction::LoadByte(ITypeArgs::new(
         4,
@@ -70,16 +92,23 @@ fn test_load_byte_instruction() {
         Some(Register::Rg2),
     ));
 
-    load_byte_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0x0000_00AB);
+    load_byte_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0x0000_00AB
+    );
 }
 
 #[test]
 fn test_load_byte_signed_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    cpu.memory.write_byte(addr, 0xFF);
-    *cpu.reg(Register::Rg1) = addr;
+    cpu.memory
+        .write_byte(addr, 0xFF)
+        .expect("Failed to write byte to memory");
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr;
 
     let load_byte_signed_instr = Instruction::LoadByteSigned(ITypeArgs::new(
         0,
@@ -87,16 +116,23 @@ fn test_load_byte_signed_instruction() {
         Some(Register::Rg2),
     ));
 
-    load_byte_signed_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0xFFFF_FFFF);
+    load_byte_signed_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0xFFFF_FFFF
+    );
 }
 
 #[test]
 fn test_load_halfword_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    cpu.memory.write_word(addr, 0x1234_5678);
-    *cpu.reg(Register::Rg1) = addr;
+    cpu.memory
+        .write_word(addr, 0x1234_5678)
+        .expect("Failed to write word to memory");
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr;
 
     let load_halfword_instr = Instruction::LoadHalfword(ITypeArgs::new(
         0,
@@ -104,16 +140,23 @@ fn test_load_halfword_instruction() {
         Some(Register::Rg2),
     ));
 
-    load_halfword_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0x0000_1234);
+    load_halfword_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0x0000_1234
+    );
 }
 
 #[test]
 fn test_load_word_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    cpu.memory.write_word(addr, 0x1234_5678);
-    *cpu.reg(Register::Rg1) = addr;
+    cpu.memory
+        .write_word(addr, 0x1234_5678)
+        .expect("Failed to write word to memory");
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr;
 
     let load_word_instr = Instruction::LoadWord(ITypeArgs::new(
         0,
@@ -121,16 +164,21 @@ fn test_load_word_instruction() {
         Some(Register::Rg2),
     ));
 
-    load_word_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0x1234_5678);
+    load_word_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0x1234_5678
+    );
 }
 
 #[test]
 fn test_store_byte_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    *cpu.reg(Register::Rg1) = addr;
-    *cpu.reg(Register::Rg2) = 0xAB;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0xAB;
 
     let store_byte_instr = Instruction::StoreByte(ITypeArgs::new(
         0,
@@ -138,16 +186,18 @@ fn test_store_byte_instruction() {
         Some(Register::Rg1),
     ));
 
-    store_byte_instr.execute(&mut cpu);
-    assert_eq!(cpu.memory.read_byte(addr), 0xAB);
+    store_byte_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(cpu.memory.read_byte(addr).expect("Emulator was slain by losing the game while attempting to execute instruction"), 0xAB);
 }
 
 #[test]
 fn test_store_word_instruction() {
     let mut cpu = create_test_processor();
     let addr = 0x100;
-    *cpu.reg(Register::Rg1) = addr;
-    *cpu.reg(Register::Rg2) = 0x1234_5678;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = addr;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0x1234_5678;
 
     let store_word_instr = Instruction::StoreWord(ITypeArgs::new(
         0,
@@ -155,15 +205,17 @@ fn test_store_word_instruction() {
         Some(Register::Rg1),
     ));
 
-    store_word_instr.execute(&mut cpu);
-    assert_eq!(cpu.memory.read_word(addr), 0x1234_5678);
+    store_word_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(cpu.memory.read_word(addr).expect("Emulator was slain by losing the game while attempting to execute instruction"), 0x1234_5678);
 }
 
 #[test]
 fn test_add_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 15;
-    *cpu.reg(Register::Rg2) = 25;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 15;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 25;
 
     let add_instr = Instruction::Add(RTypeArgs::new(
         Some(Register::Rg1),
@@ -172,15 +224,20 @@ fn test_add_instruction() {
         None,
     ));
 
-    add_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), 40);
+    add_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        40
+    );
 }
 
 #[test]
 fn test_sub_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 50;
-    *cpu.reg(Register::Rg2) = 20;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 50;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 20;
 
     let sub_instr = Instruction::Sub(RTypeArgs::new(
         Some(Register::Rg1),
@@ -189,15 +246,20 @@ fn test_sub_instruction() {
         None,
     ));
 
-    sub_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), 30);
+    sub_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        30
+    );
 }
 
 #[test]
 fn test_and_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let and_instr = Instruction::And(RTypeArgs::new(
         Some(Register::Rg1),
@@ -206,15 +268,20 @@ fn test_and_instruction() {
         None,
     ));
 
-    and_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), 0b1000);
+    and_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        0b1000
+    );
 }
 
 #[test]
 fn test_or_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let or_instr = Instruction::Or(RTypeArgs::new(
         Some(Register::Rg1),
@@ -223,15 +290,20 @@ fn test_or_instruction() {
         None,
     ));
 
-    or_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), 0b1110);
+    or_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        0b1110
+    );
 }
 
 #[test]
 fn test_xor_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let xor_instr = Instruction::Xor(RTypeArgs::new(
         Some(Register::Rg1),
@@ -240,14 +312,19 @@ fn test_xor_instruction() {
         None,
     ));
 
-    xor_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), 0b0110);
+    xor_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        0b0110
+    );
 }
 
 #[test]
 fn test_not_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0x0F0F_0F0F;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x0F0F_0F0F;
 
     let not_instr = Instruction::Not(RTypeArgs::new(
         Some(Register::Rg1),
@@ -256,15 +333,20 @@ fn test_not_instruction() {
         None,
     ));
 
-    not_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg2), 0xF0F0_F0F0);
+    not_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg2).expect("Failed to get register Rg2"),
+        0xF0F0_F0F0
+    );
 }
 
 #[test]
 fn test_compare_equal() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 42;
-    *cpu.reg(Register::Rg2) = 42;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 42;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 42;
 
     let cmp_instr = Instruction::Compare(RTypeArgs::new(
         Some(Register::Rg1),
@@ -273,18 +355,26 @@ fn test_compare_equal() {
         None,
     ));
 
-    cmp_instr.execute(&mut cpu);
+    cmp_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
 
-    assert!(cpu.get_flag(Flag::Equal));
-    assert!(!cpu.get_flag(Flag::GreaterThan));
-    assert!(!cpu.get_flag(Flag::LessThan));
+    assert!(cpu.get_flag(Flag::Equal).expect("Failed to get flag Equal"));
+    assert!(
+        !cpu.get_flag(Flag::GreaterThan)
+            .expect("Failed to get flag GreaterThan")
+    );
+    assert!(
+        !cpu.get_flag(Flag::LessThan)
+            .expect("Failed to get flag LessThan")
+    );
 }
 
 #[test]
 fn test_compare_greater_than() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 50;
-    *cpu.reg(Register::Rg2) = 30;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 50;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 30;
 
     let cmp_instr = Instruction::Compare(RTypeArgs::new(
         Some(Register::Rg1),
@@ -293,18 +383,26 @@ fn test_compare_greater_than() {
         None,
     ));
 
-    cmp_instr.execute(&mut cpu);
+    cmp_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
 
-    assert!(!cpu.get_flag(Flag::Equal));
-    assert!(cpu.get_flag(Flag::GreaterThan));
-    assert!(!cpu.get_flag(Flag::LessThan));
+    assert!(!cpu.get_flag(Flag::Equal).expect("Failed to get flag Equal"));
+    assert!(
+        cpu.get_flag(Flag::GreaterThan)
+            .expect("Failed to get flag GreaterThan")
+    );
+    assert!(
+        !cpu.get_flag(Flag::LessThan)
+            .expect("Failed to get flag LessThan")
+    );
 }
 
 #[test]
 fn test_compare_less_than() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 20;
-    *cpu.reg(Register::Rg2) = 30;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 20;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 30;
 
     let cmp_instr = Instruction::Compare(RTypeArgs::new(
         Some(Register::Rg1),
@@ -313,41 +411,59 @@ fn test_compare_less_than() {
         None,
     ));
 
-    cmp_instr.execute(&mut cpu);
+    cmp_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
 
-    assert!(!cpu.get_flag(Flag::Equal));
-    assert!(!cpu.get_flag(Flag::GreaterThan));
-    assert!(cpu.get_flag(Flag::LessThan));
+    assert!(!cpu.get_flag(Flag::Equal).expect("Failed to get flag Equal"));
+    assert!(
+        !cpu.get_flag(Flag::GreaterThan)
+            .expect("Failed to get flag GreaterThan")
+    );
+    assert!(
+        cpu.get_flag(Flag::LessThan)
+            .expect("Failed to get flag LessThan")
+    );
 }
 
 #[test]
 fn test_increment_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 42;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 42;
 
     let inc_instr =
         Instruction::Increment(RTypeArgs::new(Some(Register::Rg1), None, None, None));
 
-    inc_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 43);
+    inc_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        43
+    );
 }
 
 #[test]
 fn test_decrement_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 42;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 42;
 
     let dec_instr =
         Instruction::Decrement(RTypeArgs::new(Some(Register::Rg1), None, None, None));
 
-    dec_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 41);
+    dec_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        41
+    );
 }
 
 #[test]
 fn test_shift_left_with_shamt() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1010;
 
     let shl_instr = Instruction::ShiftLeft(RTypeArgs::new(
         Some(Register::Rg1),
@@ -356,14 +472,19 @@ fn test_shift_left_with_shamt() {
         Some(2),
     ));
 
-    shl_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 0b10_1000);
+    shl_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        0b10_1000
+    );
 }
 
 #[test]
 fn test_shift_right_with_shamt() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b10_1000;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b10_1000;
 
     let shr_instr = Instruction::ShiftRight(RTypeArgs::new(
         Some(Register::Rg1),
@@ -372,26 +493,32 @@ fn test_shift_right_with_shamt() {
         Some(2),
     ));
 
-    shr_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 0b1010);
+    shr_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        0b1010
+    );
 }
 
-#[test]
-fn test_shift_left_with_register() {
-    let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1010;
-    *cpu.reg(Register::Rg2) = 3;
+// #[test]
+// fn test_shift_left_with_register() {
+//     let mut cpu = create_test_processor();
+//     *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1010;
 
-    let shl_instr = Instruction::ShiftLeft(RTypeArgs::new(
-        Some(Register::Rg1),
-        Some(Register::Rg2),
-        None,
-        None,
-    ));
+//     let shl_instr =
+//         Instruction::ShiftLeft(RTypeArgs::new(Some(Register::Rg1), None, None,
+// Some(3)));
 
-    shl_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 0b101_0000);
-}
+//     shl_instr.execute(&mut cpu).expect(
+//         "Emulator was slain by losing the game while attempting to execute
+// instruction",     );
+//     assert_eq!(
+//         cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+//         0b101_0000
+//     );
+// }
 
 #[test]
 fn test_load_lower_immediate() {
@@ -403,14 +530,19 @@ fn test_load_lower_immediate() {
         None,
     ));
 
-    lli_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 0x0000_1234);
+    lli_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        0x0000_1234
+    );
 }
 
 #[test]
 fn test_load_upper_immediate() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0x0000_5678;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x0000_5678;
 
     let lui_instr = Instruction::LoadUpperImmediate(ITypeArgs::new(
         0x1234,
@@ -418,48 +550,71 @@ fn test_load_upper_immediate() {
         None,
     ));
 
-    lui_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg1), 0x1234_5678);
+    lui_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg1).expect("Failed to get register Rg1"),
+        0x1234_5678
+    );
 }
 
 #[test]
 fn test_jump_unconditional() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0x1000;
-    let initial_pc = cpu.get(Register::Pcx);
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x1000;
+    let initial_pc = cpu.get(Register::Pcx).expect("Failed to get register Pcx");
 
     let jump_instr = Instruction::Jump(ITypeArgs::new(0x100, Some(Register::Rg1), None));
 
-    jump_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Pcx), 0x1100);
-    assert_ne!(cpu.get(Register::Pcx), initial_pc);
+    jump_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Pcx).expect("Failed to get register Pcx"),
+        0x1100
+    );
+    assert_ne!(
+        cpu.get(Register::Pcx).expect("Failed to get register Pcx"),
+        initial_pc
+    );
 }
 
 #[test]
 fn test_jump_equal_when_flag_set() {
     let mut cpu = create_test_processor();
     cpu.set_flag(Flag::Equal, true);
-    *cpu.reg(Register::Rg1) = 0x1000;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x1000;
 
     let jump_eq_instr =
         Instruction::JumpEq(ITypeArgs::new(0x100, Some(Register::Rg1), None));
 
-    jump_eq_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Pcx), 0x1100);
+    jump_eq_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Pcx).expect("Failed to get register Pcx"),
+        0x1100
+    );
 }
 
 #[test]
 fn test_jump_equal_when_flag_not_set() {
     let mut cpu = create_test_processor();
     cpu.set_flag(Flag::Equal, false);
-    *cpu.reg(Register::Rg1) = 0x1000;
-    let initial_pc = cpu.get(Register::Pcx);
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0x1000;
+    let initial_pc = cpu.get(Register::Pcx).expect("Failed to get register Pcx");
 
     let jump_eq_instr =
         Instruction::JumpEq(ITypeArgs::new(0x100, Some(Register::Rg1), None));
 
-    jump_eq_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Pcx), initial_pc);
+    jump_eq_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Pcx).expect("Failed to get register Pcx"),
+        initial_pc
+    );
 }
 
 #[test]
@@ -467,15 +622,17 @@ fn test_halt_instruction() {
     let mut cpu = create_test_processor();
     assert!(!cpu.halted);
 
-    Instruction::Halt.execute(&mut cpu);
+    Instruction::Halt.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
     assert!(cpu.halted);
 }
 
 #[test]
 fn test_nand_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let nand_instr = Instruction::Nand(RTypeArgs::new(
         Some(Register::Rg1),
@@ -484,15 +641,20 @@ fn test_nand_instruction() {
         None,
     ));
 
-    nand_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), !0b1000);
+    nand_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        !0b1000
+    );
 }
 
 #[test]
 fn test_nor_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let nor_instr = Instruction::Nor(RTypeArgs::new(
         Some(Register::Rg1),
@@ -501,15 +663,20 @@ fn test_nor_instruction() {
         None,
     ));
 
-    nor_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), !0b1110);
+    nor_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        !0b1110
+    );
 }
 
 #[test]
 fn test_xnor_instruction() {
     let mut cpu = create_test_processor();
-    *cpu.reg(Register::Rg1) = 0b1100;
-    *cpu.reg(Register::Rg2) = 0b1010;
+    *cpu.reg(Register::Rg1).expect("Failed to get register Rg1") = 0b1100;
+    *cpu.reg(Register::Rg2).expect("Failed to get register Rg2") = 0b1010;
 
     let xnor_instr = Instruction::Xnor(RTypeArgs::new(
         Some(Register::Rg1),
@@ -518,6 +685,11 @@ fn test_xnor_instruction() {
         None,
     ));
 
-    xnor_instr.execute(&mut cpu);
-    assert_eq!(cpu.get(Register::Rg3), !0b0110);
+    xnor_instr.execute(&mut cpu).expect(
+        "Emulator was slain by losing the game while attempting to execute instruction",
+    );
+    assert_eq!(
+        cpu.get(Register::Rg3).expect("Failed to get register Rg3"),
+        !0b0110
+    );
 }

emulator/src/emulator/ui/control_unit.rs

@@ -1,5 +1,3 @@
-use std::sync::mpsc::Sender;
-
 use crate::emulator::{
     system::model::{Command, Running, State},
     ui::interface::Component,
@@ -9,19 +7,27 @@ use common::{instructions::Register, prelude::Instruction};
 
 pub struct ControlPanel {
     visible: bool,
-    sender: Sender<Command>,
+    step_amount_input: String,
+    step_amount: usize,
 }
 
 impl ControlPanel {
-    #[must_use]
-    pub const fn new(sender: Sender<Command>) -> Self {
+    #[allow(clippy::must_use_candidate)]
+    pub fn new() -> Self {
         Self {
             visible: false,
-            sender,
+            step_amount_input: String::from("1"),
+            step_amount: 1,
         }
     }
 }
 
+impl Default for ControlPanel {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Component for ControlPanel {
     fn category(&self) -> super::interface::Category {
         super::interface::Category::Control
@@ -47,46 +53,76 @@ impl Component for ControlPanel {
                 .clicked()
             {
                 if state.running == Running::Running {
-                    self.sender.send(Command::Stop).unwrap_or_else(|_| {
-                        state.error = Some("Failed to send command".to_string());
+                    state.cmd_sender.send(Command::Stop).unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
                 } else {
-                    self.sender.send(Command::Start).unwrap_or_else(|_| {
-                        state.error = Some("Failed to send command".to_string());
+                    state.cmd_sender.send(Command::Start).unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
                 }
             }
 
             // Step
             if ui.button("Step").clicked() {
-                self.sender.send(Command::Step).unwrap_or_else(|_| {
-                    state.error = Some("Failed to send command".to_string());
+                state
+                    .cmd_sender
+                    .send(Command::Step(self.step_amount))
+                    .unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
             }
 
             // Resets the emulator and all attached devices
             if ui.button("Reset All").clicked() {
-                self.sender.send(Command::Reset(0)).unwrap_or_else(|_| {
-                    state.error = Some("Failed to send command".to_string());
+                state
+                    .cmd_sender
+                    .send(Command::Reset(0))
+                    .unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
             }
 
             // Resets the emulator and all attached devices
             if ui.button("Clear Registers").clicked() {
-                self.sender.send(Command::Reset(1)).unwrap_or_else(|_| {
-                    state.error = Some("Failed to send command".to_string());
+                state
+                    .cmd_sender
+                    .send(Command::Reset(1))
+                    .unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
             }
 
             // Resets the emulator and all attached devices
             if ui.button("Clear RAM").clicked() {
-                self.sender.send(Command::Reset(2)).unwrap_or_else(|_| {
-                    state.error = Some("Failed to send command".to_string());
+                state
+                    .cmd_sender
+                    .send(Command::Reset(2))
+                    .unwrap_or_else(|_| {
+                        state.error_log.push("Failed to send command".to_string());
                     });
             }
 
             ui.separator();
 
+            state.send(Command::RegisterRequest);
+            state.send(Command::RunningRequest);
+            state.send(Command::InstructionCountRequest);
+
+            if ui
+                .text_edit_singleline(&mut self.step_amount_input)
+                .changed()
+            {
+                self.step_amount = if let Ok(amount) = self.step_amount_input.parse() {
+                    amount
+                } else {
+                    state
+                        .error_log
+                        .push("Unable to parse step amount".to_string());
+                    1
+                }
+            }
+
             // Status info
             ui.label(format!(
                 "Status: {}",
@@ -97,13 +133,21 @@ impl Component for ControlPanel {
                 }
             ));
 
-            let pcx = state.reg_file.get(Register::Pcx);
+            let pcx = state
+                .reg_file
+                .get(Register::Pcx)
+                .expect("PCX should never be invalid");
             let instructions = state.instructions;
 
             ui.label(format!("Instructions: {instructions}"));
             ui.label(format!("PC: 0x{pcx:08X}"));
 
-            let instruction = Instruction::decode(state.reg_file.get(Register::Cir))
+            let instruction = Instruction::decode(
+                state
+                    .reg_file
+                    .get(Register::Cir)
+                    .expect("CIR should never be invalid"),
+            )
             .map_or_else(
                 |_| "Invalid Instruction".to_string(),
                 |instruction| instruction.to_string(),

emulator/src/emulator/ui/display.rs

@@ -1,5 +1,5 @@
 use crate::emulator::{
-    system::model::State,
+    system::model::{Command, State},
     ui::interface::{Category, Component},
 };
 
@@ -40,6 +40,8 @@ impl Component for Display {
     }
 
     fn render(&mut self, state: &mut State, ui: &mut egui::Ui, _ctx: &egui::Context) {
+        state.send(Command::DisplayRequest);
+
         let display: Vec<u8> = state.display_view.clone();
         let font_id = FontId::monospace(12.0);
 

emulator/src/emulator/ui/editor.rs

@@ -3,7 +3,6 @@ use std::{
     ffi::OsStr,
     fs,
     path::{Path, PathBuf},
-    sync::mpsc::Sender,
 };
 
 use common::prelude::Instruction;
@@ -19,6 +18,7 @@ use crate::emulator::{
 
 use assembler::prelude::*;
 
+#[derive(Default)]
 pub struct Editor {
     // editor state
     path: Option<PathBuf>,
@@ -41,7 +41,6 @@ pub struct Editor {
 
     // other
     visible: bool,
-    sender: Sender<Command>,
     error: Option<String>,
 }
 
@@ -94,14 +93,13 @@ impl Component for Editor {
 
 impl Editor {
     #[must_use]
-    pub const fn new(sender: Sender<Command>) -> Self {
+    pub const fn new() -> Self {
         Self {
             path: None,
             text: String::new(),
             buffer: String::new(),
             output: Vec::new(),
             unsaved: true,
-            sender,
             cursor_col: 1,
             cursor_line: 1,
             visible: false,
@@ -199,38 +197,6 @@ impl Editor {
             )
         });
 
-        // if let Some(path) = FileDialog::new()
-        //     .add_filter("Assembly Files or Binaries", &["dsa", "dsb"])
-        //     .add_filter("all", &["*"])
-        //     .set_directory(&work_dir)
-        //     .pick_file()
-        // {
-        //     match path.extension().and_then(|ext| ext.to_str()) {
-        //         Some("dsb") => {
-        //             let contents = match std::fs::read(&path) {
-        //                 Ok(contents) => contents,
-        //                 Err(why) => {
-        //                     self.error = Some(format!("Failed to read file: {why}"));
-        //                     return;
-        //                 }
-        //             };
-
-        //             self.path = Some(path.clone());
-        //             self.output = contents;
-        //             self.unsaved = false;
-        //             self.text = String::from("Loaded Binary File!");
-        //             self.buffer = self.text.clone();
-        //             self.unsaved = false;
-        //         }
-        //         _ => {
-        //             if let Ok(contents) = std::fs::read_to_string(&path) {
-        //                 self.path = Some(path.clone());
-        //                 self.text.clone_from(&contents);
-        //                 self.buffer = contents;
-        //                 self.unsaved = false;
-        //             }
-        //         }
-        //     }
         if self.save_file_dialog.is_some() {
             // TODO: Flash an error stating you can only have one menu open at once.
             self.save_file_dialog = None;
@@ -252,8 +218,9 @@ impl Editor {
 
     fn handle_file_dialogs(&mut self, ctx: &egui::Context) {
         // Handle open dialog
-        if let Some(dialog) = &mut self.open_file_dialog {
-            if dialog.show(ctx).selected() {
+        if let Some(dialog) = &mut self.open_file_dialog
+            && dialog.show(ctx).selected()
+        {
             if let Some(file) = dialog.path() {
                 // check if the file is a binary file
                 if file.extension().is_some_and(|ext| ext == "dsb") {
@@ -293,11 +260,11 @@ impl Editor {
             }
             self.open_file_dialog = None;
         }
-        }
 
         // Handle save dialog
-        if let Some(dialog) = &mut self.save_file_dialog {
-            if dialog.show(ctx).selected() {
+        if let Some(dialog) = &mut self.save_file_dialog
+            && dialog.show(ctx).selected()
+        {
             if let Some(file) = dialog.path() {
                 self.buffer = self.text.clone();
 
@@ -336,34 +303,6 @@ impl Editor {
             self.save_file_dialog = None;
         }
     }
-    }
-
-    // fn open(&mut self) {
-    //     let work_dir = std::env::current_dir().unwrap_or_else(|_| {
-    //         dirs::home_dir().expect(
-    //             "Couldn't get your current working directory or your home directory.",
-    //         )
-    //     });
-
-    //     if let Some(path) = FileDialog::new()
-    //         .add_filter("Assembly Files or Binaries", &["dsa", "dsb"])
-    //         .add_filter("all", &["*"])
-    //         .set_directory(&work_dir)
-    //         .pick_file()
-    //     {
-    //         if let Ok(contents) = std::fs::read_to_string(&path) {
-    //             self.path = Some(path.clone());
-    //             self.text.clone_from(&contents);
-    //             self.buffer = contents;
-    //             self.unsaved = false;
-    //         }
-
-    //         std::env::set_current_dir(
-    //             path.parent().expect("A file should be in a directory!"),
-    //         )
-    //         .expect("ERROR: Failed to set current working directory.");
-    //     }
-    // }
 
     fn render_output(&self, _state: &mut State, ui: &mut Ui, _ctx: &Context) {
         // Output area with synchronized scrolling
@@ -526,7 +465,7 @@ impl Editor {
         }
     }
 
-    fn render_toolbar(&mut self, _state: &mut State, ui: &mut Ui, ctx: &Context) {
+    fn render_toolbar(&mut self, state: &State, ui: &mut Ui, ctx: &Context) {
         self.handle_file_dialogs(ctx);
 
         ui.horizontal(|ui| {
@@ -567,7 +506,8 @@ impl Editor {
                         Some("Can't load program at invalid offset!".to_string());
                 }
 
-                self.sender
+                state
+                    .cmd_sender
                     .send(Command::Write(self.load_offset, self.output.clone()))
                     .unwrap_or_else(|_| {
                         self.error = Some("Failed to send command".to_string());

emulator/src/emulator/ui/history.rs

@@ -1,6 +1,9 @@
 use egui::{Context, Ui};
 
-use crate::emulator::{system::model::State, ui::interface::Component};
+use crate::emulator::{
+    system::model::{Command, State},
+    ui::interface::Component,
+};
 
 pub struct History {
     visible: bool,
@@ -20,11 +23,13 @@ impl Component for History {
     }
 
     fn render(&mut self, state: &mut State, ui: &mut Ui, _ctx: &Context) {
+        state.send(Command::HistoryRequest);
+
         egui::ScrollArea::vertical()
             .id_salt("output_scroll")
             .max_width(400.0)
             .show(ui, |ui| {
-                if state.persistent.history.is_empty() {
+                if state.instruction_history.is_empty() {
                     ui.label(
                         egui::RichText::new("No output data")
                             .font(egui::FontId::monospace(12.0))
@@ -40,7 +45,7 @@ impl Component for History {
                     .show(ui, |ui| {
                         // Process bytes in chunks of 4
                         for (idx, instruction) in
-                            state.persistent.history.iter().enumerate()
+                            state.instruction_history.iter().enumerate()
                         {
                             ui.label(format!("{idx}: "));
 

emulator/src/emulator/ui/interface.rs

@@ -1,4 +1,4 @@
-use crate::emulator::system::model::{Command, PersistentState, Running, State};
+use crate::emulator::system::model::{Command, Running, State, StateUpdate};
 use std::sync::mpsc::{Receiver, Sender};
 
 pub trait Component {
@@ -34,21 +34,15 @@ impl Category {
 }
 
 pub struct EmulatorUI {
-    pub sender: Sender<Command>,
-    pub receiver: Receiver<State>,
     pub state: State,
-    pub persistent: PersistentState,
     pub components: Vec<Box<dyn Component>>,
 }
 
 impl EmulatorUI {
     #[must_use]
-    pub fn new(sender: Sender<Command>, receiver: Receiver<State>) -> Self {
+    pub fn new(sender: Sender<Command>, receiver: Receiver<StateUpdate>) -> Self {
         Self {
-            sender,
-            receiver,
-            state: State::default(),
-            persistent: PersistentState::default(),
+            state: State::new(sender, receiver),
             components: vec![],
         }
     }
@@ -56,19 +50,13 @@ impl EmulatorUI {
     pub fn add_component(&mut self, component: Box<dyn Component>) {
         self.components.push(component);
     }
-
-    fn update_state(&mut self) {
-        while let Ok(state) = self.receiver.try_recv() {
-            self.state = state;
-            self.persistent.update(&self.state.persistent);
-            self.state.persistent = self.persistent.clone();
-        }
-    }
 }
 
 impl eframe::App for EmulatorUI {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        self.update_state();
+        if let Err(e) = self.state.update() {
+            self.state.error_log.push(e.to_string());
+        }
 
         if self.state.running == Running::Running {
             ctx.request_repaint();

emulator/src/emulator/ui/loader.rs

@@ -0,0 +1,294 @@
+use std::{
+    ffi::OsStr,
+    path::{Path, PathBuf},
+};
+
+use common::prelude::Instruction;
+use egui::{Context, Ui};
+use egui_file::FileDialog;
+
+use crate::emulator::{
+    system::model::{Command, State},
+    ui::interface::Component,
+};
+
+#[derive(Default)]
+pub struct Loader {
+    path: Option<PathBuf>,
+    output: Vec<u8>,
+    load_offset: u32,
+    offset_str: String,
+
+    // file dialogs
+    open_file_dialog: Option<FileDialog>,
+
+    // other
+    visible: bool,
+    error: Option<String>,
+}
+
+impl Component for Loader {
+    fn name(&self) -> &'static str {
+        "Loader"
+    }
+
+    fn visible(&mut self) -> &mut bool {
+        &mut self.visible
+    }
+
+    fn category(&self) -> super::interface::Category {
+        super::interface::Category::Programming
+    }
+
+    fn render(&mut self, state: &mut State, ui: &mut Ui, ctx: &Context) {
+        ui.vertical(|ui| {
+            self.render_toolbar(state, ui, ctx);
+
+            ui.add_space(4.0); // Add some spacing instead of just a separator
+            ui.separator();
+
+            egui::ScrollArea::vertical()
+                .auto_shrink([false; 2])
+                .max_height(ui.available_height() - 100.0)
+                .show(ui, |ui| {
+                    self.render_output(state, ui, ctx);
+                });
+
+            self.render_bottom_bar(state, ui, ctx);
+        });
+    }
+}
+
+impl Loader {
+    #[must_use]
+    pub const fn new() -> Self {
+        Self {
+            path: None,
+            output: Vec::new(),
+            visible: false,
+            load_offset: 0,
+            offset_str: String::new(),
+            error: None,
+            open_file_dialog: None,
+        }
+    }
+
+    fn filename(&self) -> &str {
+        if let Some(path) = &self.path {
+            return path
+                .file_name()
+                .unwrap_or_else(|| OsStr::new("Unnamed!"))
+                .to_str()
+                .map_or_else(
+                    || unreachable!("File name should be valid UTF-8."),
+                    |ext| ext,
+                );
+        }
+        "Unnamed!"
+    }
+
+    fn open(&mut self) {
+        let work_dir = std::env::current_dir().unwrap_or_else(|_| {
+            dirs::home_dir().expect(
+                "Couldn't get your current working directory or your home directory.",
+            )
+        });
+
+        if self.open_file_dialog.is_some() {
+            // TODO: Flash an error stating you can only have one menu open at once.
+            self.open_file_dialog = None;
+        }
+
+        if self.open_file_dialog.is_none() {
+            if let Some(p) = &self.path {
+                let path = p.parent().map(Path::to_path_buf);
+                let mut dialog = FileDialog::open_file(path);
+                dialog.open();
+                self.open_file_dialog = Some(dialog);
+            } else {
+                let mut dialog = FileDialog::open_file(Some(work_dir));
+                dialog.open();
+                self.open_file_dialog = Some(dialog);
+            }
+        }
+    }
+
+    fn handle_file_dialogs(&mut self, ctx: &egui::Context) {
+        // Handle open dialog
+        if let Some(dialog) = &mut self.open_file_dialog
+            && dialog.show(ctx).selected()
+        {
+            if let Some(file) = dialog.path() {
+                // check if the file is a binary file
+                if file.extension().is_some_and(|ext| ext == "dsb") {
+                    match std::fs::read(file) {
+                        Ok(content) => {
+                            self.output = content;
+                            self.error = None;
+                        }
+                        Err(e) => {
+                            self.error = Some(format!("Failed to read file: {e}"));
+                        }
+                    }
+                }
+            }
+            self.open_file_dialog = None;
+        }
+    }
+
+    fn render_output(&self, _state: &mut State, ui: &mut Ui, _ctx: &Context) {
+        // Output area with synchronized scrolling
+        egui::ScrollArea::vertical()
+            .id_salt("output_scroll")
+            .max_width(400.0)
+            .show(ui, |ui| {
+                if self.output.is_empty() {
+                    ui.label(
+                        egui::RichText::new("No output data")
+                            .font(egui::FontId::monospace(12.0))
+                            .color(egui::Color32::GRAY),
+                    );
+                    return;
+                }
+
+                egui::Grid::new("output_grid")
+                    .spacing([5.0, 2.0]) // Horizontal and vertical spacing
+                    .num_columns(4)
+                    .striped(false)
+                    .show(ui, |ui| {
+                        // Process bytes in chunks of 4
+                        for (line_num, chunk) in self.output.chunks(4).enumerate() {
+                            let address = line_num * 4;
+
+                            // Convert chunk to u32 (little-endian)
+                            let mut bytes = [0u8; 4];
+                            for (i, &byte) in chunk.iter().enumerate() {
+                                if i < 4 {
+                                    bytes[i] = byte;
+                                }
+                            }
+                            let value = u32::from_be_bytes(bytes);
+
+                            // Address column
+                            ui.with_layout(
+                                egui::Layout::left_to_right(egui::Align::Center),
+                                |ui| {
+                                    ui.set_min_width(80.0);
+                                    let style = ui.style_mut();
+                                    style.visuals.widgets.inactive.bg_fill =
+                                        egui::Color32::from_gray(30);
+                                    ui.label(
+                                        egui::RichText::new(format!("0x{address:04X}"))
+                                            .font(egui::FontId::monospace(12.0)),
+                                    );
+                                },
+                            );
+
+                            // Individual bytes column
+                            let byte_str = chunk
+                                .iter()
+                                .map(|b| format!("{b:02X}"))
+                                .collect::<Vec<_>>()
+                                .join(" ");
+
+                            ui.label(
+                                egui::RichText::new(format!("{byte_str:<11}"))
+                                    .font(egui::FontId::monospace(12.0))
+                                    .color(egui::Color32::from_rgb(200, 200, 255)),
+                            );
+
+                            // Hex column
+                            ui.label(
+                                egui::RichText::new(format!("0x{value:08X}"))
+                                    .font(egui::FontId::monospace(12.0))
+                                    .color(egui::Color32::from_rgb(255, 200, 200)),
+                            );
+
+                            // Instruction column
+                            let instruction = Instruction::decode(value).map_or_else(
+                                |_| format!("{value:10}"),
+                                |instruction| instruction.to_string(),
+                            );
+
+                            ui.label(
+                                egui::RichText::new(instruction)
+                                    .font(egui::FontId::monospace(12.0))
+                                    .color(egui::Color32::from_rgb(200, 255, 200)),
+                            );
+
+                            ui.end_row();
+                        }
+                    });
+            });
+    }
+
+    fn render_bottom_bar(&self, _state: &mut State, ui: &mut Ui, _ctx: &Context) {
+        ui.horizontal(|ui| {
+            // error display
+            ui.label(
+                egui::RichText::new(self.error.clone().unwrap_or_default())
+                    .color(egui::Color32::RED),
+            );
+        });
+    }
+
+    fn render_toolbar(&mut self, state: &State, ui: &mut Ui, ctx: &Context) {
+        self.handle_file_dialogs(ctx);
+
+        ui.horizontal(|ui| {
+            ui.label(format!("Filename: {}", self.filename()));
+        });
+
+        ui.horizontal(|ui| {
+            ui.spacing_mut().button_padding = egui::vec2(8.0, 4.0);
+            ui.spacing_mut().item_spacing.x = 6.0;
+
+            // Opens a file
+            if ui.button("Open").clicked() {
+                self.open();
+            }
+
+            // Loads the generated binary into the assembler at the provided offset
+            if ui.button("Load").clicked() {
+                if self.error.is_some() {
+                    self.error =
+                        Some("Can't load program at invalid offset!".to_string());
+                }
+
+                state
+                    .cmd_sender
+                    .send(Command::Write(self.load_offset, self.output.clone()))
+                    .unwrap_or_else(|_| {
+                        self.error = Some("Failed to send command".to_string());
+                    });
+            }
+
+            // Entry widget to enter a load offset
+            if ui.text_edit_singleline(&mut self.offset_str).changed() {
+                if let Some(offset) = parse_address(&self.offset_str) {
+                    self.load_offset = offset;
+                    self.error = None;
+                } else {
+                    self.error = Some("Invalid offset".to_string());
+                }
+            }
+        });
+    }
+}
+
+fn parse_address(address: &str) -> Option<u32> {
+    address.strip_prefix("0x").map_or_else(
+        || {
+            address.strip_prefix("0b").map_or_else(
+                || {
+                    address.strip_prefix("0o").map_or_else(
+                        || address.parse::<u32>().ok(),
+                        |oct| u32::from_str_radix(oct, 8).ok(),
+                    )
+                },
+                |bin| u32::from_str_radix(bin, 2).ok(),
+            )
+        },
+        |hex| u32::from_str_radix(hex, 16).ok(),
+    )
+}

emulator/src/emulator/ui/memory_inspector.rs

@@ -1,4 +1,4 @@
-use std::{num::ParseIntError, sync::mpsc::Sender};
+use std::num::ParseIntError;
 
 use common::prelude::Instruction;
 
@@ -7,23 +7,22 @@ use crate::emulator::{
     ui::interface::Component,
 };
 
+#[derive(Default)]
 pub struct MemoryInspector {
     view_size: u32,
     view_addr: u32,
     visible: bool,
     addr_input: String,
-    sender: Sender<Command>,
 }
 
 impl MemoryInspector {
     #[must_use]
-    pub const fn new(sender: Sender<Command>) -> Self {
+    pub const fn new() -> Self {
         Self {
             view_size: 256,
             view_addr: 0,
             visible: false,
             addr_input: String::new(),
-            sender,
         }
     }
 }
@@ -63,28 +62,26 @@ impl Component for MemoryInspector {
                 let search_clicked = ui.button("🔍 Search").clicked();
 
                 // Handle Enter key in text field
-                let enter_pressed =
-                    address_response.lost_focus() && ctx.input(|i| i.key_pressed(egui::Key::Enter));
+                let enter_pressed = address_response.lost_focus()
+                    && ctx.input(|i| i.key_pressed(egui::Key::Enter));
 
                 if search_clicked || enter_pressed {
                     if let Ok(new) = parse_address(&self.addr_input) {
                         self.view_addr = new;
-
-                        if let Err(why) = self.sender.send(Command::Read(new, self.view_size)) {
-                            panic!(
-                                "Error sending message across threads -- cannot be recovered: {why}"
-                            )
-                        }
                     } else {
-                        state.error = Some("Invalid address".to_string());
+                        state.error_log.push("Invalid address".to_string());
                     }
                 }
 
+                let _ = state
+                    .cmd_sender
+                    .send(Command::MemRequest(self.view_addr, self.view_size));
+
                 ui.label("(hex or decimal)");
             });
 
             // Show input error if any
-            if let Some(error) = &state.error {
+            if let Some(error) = state.error_log.last() {
                 ui.colored_label(egui::Color32::RED, format!("Error: {error}"));
             }
 
@@ -113,9 +110,12 @@ impl Component for MemoryInspector {
                             ui.end_row();
 
                             // Memory data (8 bytes per row)
-                            for (row, chunk) in (0u32..).zip(state.memory_view.chunks(4)) {
+                            for (row, chunk) in (0u32..).zip(state.memory_view.chunks(4))
+                            {
                                 let row_address = self.view_addr + (row * 4);
-                                ui.monospace(format!("0x{row_address:08X} ({row_address})"));
+                                ui.monospace(format!(
+                                    "0x{row_address:08X} ({row_address})"
+                                ));
                                 for &byte in chunk {
                                     ui.monospace(format!("{byte:02X}"));
                                 }
@@ -126,12 +126,16 @@ impl Component for MemoryInspector {
                                 }
 
                                 // combine all 4 bytes in the chunk into a u32
-                                let combined = chunk
-                                    .iter()
-                                    .fold(0u32, |acc, &byte| (acc << 8) | u32::from(byte));
+                                let combined = chunk.iter().fold(0u32, |acc, &byte| {
+                                    (acc << 8) | u32::from(byte)
+                                });
 
                                 ui.monospace(format!("{combined}"));
-                                ui.monospace(format!("{}", Instruction::decode(combined).unwrap_or(Instruction::Nop)));
+                                ui.monospace(format!(
+                                    "{}",
+                                    Instruction::decode(combined)
+                                        .unwrap_or(Instruction::Nop)
+                                ));
 
                                 ui.end_row();
                             }

emulator/src/emulator/ui/mod.rs

@@ -3,6 +3,7 @@ pub mod display;
 pub mod editor;
 pub mod history;
 pub mod interface;
+pub mod loader;
 pub mod memory_inspector;
 pub mod menu;
 pub mod stack_inspector;

emulator/src/emulator/ui/stack_inspector.rs

@@ -1,4 +1,7 @@
-use crate::emulator::{system::model::State, ui::interface::Component};
+use crate::emulator::{
+    system::model::{Command, State},
+    ui::interface::Component,
+};
 
 use common::instructions::Register;
 
@@ -33,6 +36,8 @@ impl Component for StackInspector {
     }
 
     fn render(&mut self, state: &mut State, ui: &mut egui::Ui, _ctx: &egui::Context) {
+        state.send(Command::StackRequest);
+
         ui.vertical(|ui| {
             ui.heading("Stack Inspector");
             egui::ScrollArea::vertical()
@@ -56,7 +61,7 @@ impl Component for StackInspector {
                                 ui.label(format!(
                                     "{} [{}]",
                                     i,
-                                    state.reg_file.get(Register::Spr) - i as u32 * 4
+                                    state.reg_file.get(Register::Spr).expect("SPR should never be invalid") - i as u32 * 4
                                 ));
                                 ui.label(format!("0x{value:08X} ({value})"));
                                 ui.end_row();

emulator/src/lib.rs

@@ -30,7 +30,7 @@ use crate::emulator::{
     system::{
         emulator::run_emulator,
         memory::MainStore,
-        model::{Command, State},
+        model::{Command, StateUpdate},
         processor::Processor,
     },
     ui::{
@@ -86,7 +86,7 @@ pub fn android_main(app: AndroidApp) -> Result<(), Box<dyn std::error::Error>> {
 
 pub fn setup_emulator(
     cmd_receiver: Receiver<Command>,
-    state_sender: Sender<State>,
+    state_sender: Sender<StateUpdate>,
     rpc_client: Option<Arc<RpcClient>>,
 ) {
     let main_store = MainStore::new();
@@ -101,22 +101,22 @@ pub fn setup_emulator(
 #[must_use]
 pub fn setup_ui(
     cmd_sender: Sender<Command>,
-    state_reciever: Receiver<State>,
+    state_reciever: Receiver<StateUpdate>,
 ) -> EmulatorUI {
-    let mut ui = EmulatorUI::new(cmd_sender.clone(), state_reciever);
+    let mut ui = EmulatorUI::new(cmd_sender, state_reciever);
 
     // Create UI modules.
-    let control_unit = ControlPanel::new(cmd_sender.clone());
+    let control_unit = ControlPanel::new();
 
     ui.add_component(Box::new(control_unit));
 
-    let mem_inspector = MemoryInspector::new(cmd_sender.clone());
+    let mem_inspector = MemoryInspector::new();
     ui.add_component(Box::new(mem_inspector));
 
     let stack_inspector = StackInspector::new();
     ui.add_component(Box::new(stack_inspector));
 
-    let editor = Editor::new(cmd_sender);
+    let editor = Editor::new();
     ui.add_component(Box::new(editor));
 
     let display = Display::new();
@@ -125,5 +125,8 @@ pub fn setup_ui(
     let history = emulator::ui::history::History::new();
     ui.add_component(Box::new(history));
 
+    let loader = emulator::ui::loader::Loader::new();
+    ui.add_component(Box::new(loader));
+
     ui
 }

resources/concept/assemblerconcept.md

@@ -1,279 +0,0 @@
-
-
-```rust
-// src/assembler/source.rs
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct SourcePosition {
-    pub line: u32,
-    pub column: u32,
-    pub offset: usize,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SourceSpan {
-    pub start: SourcePosition,
-    pub end: SourcePosition,
-    pub file_id: u64,  // Hash of the file path
-}
-
-impl SourceSpan {
-    pub fn new(start: SourcePosition, end: SourcePosition, file_id: u64) -> Self {
-        Self { start, end, file_id }
-    }
-    
-    pub fn single_char(pos: SourcePosition, file_id: u64) -> Self {
-        Self {
-            start: pos,
-            end: pos,
-            file_id,
-        }
-    }
-}
-2. Enhanced Token with Source Information
-Update the Token type to include source positions:
-
-```rust
-// src/assembler/model.rs
-pub struct Token {
-    pub kind: TokenKind,
-    pub span: SourceSpan,
-    pub raw: String,  // Original source text
-}
-
-pub enum TokenKind {
-    // ... existing variants ...
-}
-3. Enhanced CodeModule Structure
-Enhance the 
-CodeModule
- struct to track source information:
-
-```rust
-// src/assembler/mod.rs
-pub struct CodeModule {
-    pub path: PathBuf,
-    pub hash: u64,
-    pub source: String,
-    pub lines: Vec<usize>,  // Line start offsets for quick lookup
-    pub tokens: Vec<Token>,
-    pub nodes: Vec<Node>,
-    pub dependencies: Vec<CodeModule>,
-}
-
-impl CodeModule {
-    pub fn new(path: PathBuf, source: String) -> Self {
-        let hash = quick_hash(&path);
-        let lines = source.lines()
-            .scan(0, |offset, line| {
-                let start = *offset;
-                *offset += line.len() + 1;  // +1 for newline
-                Some(start)
-            })
-            .collect();
-            
-        Self {
-            path,
-            hash,
-            source,
-            lines,
-            tokens: Vec::new(),
-            nodes: Vec::new(),
-            dependencies: Vec::new(),
-        }
-    }
-    
-    pub fn position_from_offset(&self, offset: usize) -> (u32, u32) {
-        match self.lines.binary_search(&offset) {
-            Ok(line) => (line as u32 + 1, 1),
-            Err(0) => (1, offset as u32 + 1),
-            Err(line) => {
-                let line_start = self.lines[line - 1];
-                (line as u32, (offset - line_start + 1) as u32)
-            }
-        }
-    }
-}
-4. Enhanced Lexer with Source Positions
-Update the lexer to track source positions:
-
-```rust
-// src/assembler/lexer.rs
-pub fn lex(module: &mut CodeModule) -> Result<(), AssembleError> {
-    let source = &module.source;
-    let mut tokens = Vec::new();
-    let mut pos = 0;
-    let mut line_start = 0;
-    let mut line = 1;
-    
-    while pos < source.len() {
-        let c = source[pos..].chars().next().unwrap();
-        
-        if c == '\n' {
-            line += 1;
-            line_start = pos + 1;
-            pos += 1;
-            continue;
-        }
-        
-        if c.is_whitespace() {
-            pos += 1;
-            continue;
-        }
-        
-        let token_start = pos;
-        // ... existing token parsing logic ...
-        
-        // When creating a token:
-        let start_pos = SourcePosition {
-            line,
-            column: (token_start - line_start + 1) as u32,
-            offset: token_start,
-        };
-        
-        // Update pos based on token length
-        let token_length = /* calculate token length */;
-        pos += token_length;
-        
-        let end_pos = SourcePosition {
-            line,
-            column: (pos - line_start + 1) as u32,
-            offset: pos,
-        };
-        
-        tokens.push(Token {
-            kind: token_kind,
-            span: SourceSpan::new(start_pos, end_pos, module.hash),
-            raw: source[token_start..pos].to_string(),
-        });
-    }
-    
-    module.tokens = tokens;
-    Ok(())
-}
-5. Enhanced Error Reporting
-Create a structured error type with source context:
-
-```rust
-// src/assembler/error.rs
-#[derive(Debug)]
-pub struct AssemblerError {
-    pub kind: ErrorKind,
-    pub span: SourceSpan,
-    pub message: String,
-    pub context: Vec<String>,
-}
-
-impl AssemblerError {
-    pub fn new(kind: ErrorKind, span: SourceSpan, message: impl Into<String>) -> Self {
-        Self {
-            kind,
-            span,
-            message: message.into(),
-            context: Vec::new(),
-        }
-    }
-    
-    pub fn with_context(mut self, context: impl Into<String>) -> Self {
-        self.context.push(context.into());
-        self
-    }
-    
-    pub fn format(&self, module: &CodeModule) -> String {
-        let (line, col) = module.position_from_offset(self.span.start.offset);
-        let line_content = module.source.lines().nth(line as usize - 1).unwrap_or("");
-        
-        let mut output = format!(
-            "{}:{}:{}: {}\n",
-            module.path.display(),
-            line,
-            col,
-            self.message
-        );
-        
-        // Add source line with caret
-        output.push_str(&format!("{}\n", line_content));
-        output.push_str(&" ".repeat(col as usize - 1));
-        output.push_str("^\n");
-        
-        // Add context if any
-        for ctx in &self.context {
-            output.push_str(&format!("  = note: {}\n", ctx));
-        }
-        
-        output
-    }
-}
-6. Integration with Compilation Pipeline
-Update the compilation pipeline to use the enhanced types:
-
-```rust
-// src/assembler/mod.rs
-pub fn assemble(src: &Path) -> Result<Vec<Instruction>, AssemblerError> {
-    let source = std::fs::read_to_string(src)
-        .map_err(|e| AssemblerError::io_error(src, e))?;
-    
-    let mut module = CodeModule::new(src.to_path_buf(), source);
-    
-    // Lexing
-    lexer::lex(&mut module)?;
-    
-    // Parsing
-    parser::parse(&mut module)?;
-    
-    // Resolution
-    resolver::resolve(&mut module)?;
-    
-    // Code generation
-    codegen::generate(&module)
-}
-7. Logging Integration
-Enhance the logging system to include source context:
-
-```rust
-// src/util/logging.rs
-pub trait Loggable {
-    fn log(&self, level: LogLevel, message: impl std::fmt::Display);
-    fn log_with_span(&self, level: LogLevel, span: &SourceSpan, message: impl std::fmt::Display);
-}
-
-impl Loggable for CodeModule {
-    fn log_with_span(&self, level: LogLevel, span: &SourceSpan, message: impl std::fmt::Display) {
-        if span.file_id != self.hash {
-            if let Some(dep) = self.find_dependency(span.file_id) {
-                return dep.log_with_span(level, span, message);
-            }
-        }
-        
-        let (line, col) = self.position_from_offset(span.start.offset);
-        let line_content = self.source.lines().nth(line as usize - 1).unwrap_or("");
-        
-        log::log!(
-            level,
-            "{}:{}:{}: {}\n  {}\n  {}{}",
-            self.path.display(),
-            line,
-            col,
-            message,
-            line_content,
-            " ".repeat(col as usize - 1),
-            "^"
-        );
-    }
-}
-8. Usage Example
-Here's how you'd use this in practice:
-
-```rust
-// In your parser or code that needs to report errors
-fn parse_token(&mut self, module: &CodeModule) -> Result<Token, AssemblerError> {
-    // ...
-    if !is_valid_token(&token) {
-        return Err(AssemblerError::new(
-            ErrorKind::SyntaxError,
-            token.span,
-            "Invalid token"
-        ).with_context("Expected a valid instruction or directive"));
-    }
-    // ...
-}
-```

resources/dsa/bf.dsa

@@ -2,10 +2,38 @@
 // a simple brainf##k interpreter,
 // because I already wrote a compiler lol.
 
-include print "./lib/print.dsa"
+include print "./lib/io/print.dsa"
 
 // "print hello world"
-db program: "++++++[>++++++++++++<-]>.>++++++++++[>++++++++++<-]>+.+++++++..+++.>++++[>+++++++++++<-]>.<+++[>----<-]>.<<<<<+++[>+++++<-]>.>>.+++.------.--------.>>+."
+db program: "++++++++++++++++++++++++++++++++++++++++++++
+>++++++++++++++++++++++++++++++++
+>++++++++++++++++
+>
+>+
+<<
+[
+>>
+>
+>++++++++++
+<<
+[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]
+>[<+>-]
+>[-]
+>>
+>++++++++++
+<
+[->-[>+>>]>[+[-<+>]>+>>]<<<<<]
+>[-]
+>>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]
+<[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]
+<<<++++++++++++++++++++++++++++++++++++++++++++++++.[-]
+<<<<<<<.>.
+>>[>>+<<-]
+>[>+<<+>-]
+>[<+>-]
+<<<-
+]
+<<++..."
 
 db error: "Invalid Instruction!"
 dw stack: 0x10000
@@ -20,6 +48,7 @@ _init_stack:
 start:
     // load the start of the program into rg0
     lwi program, rg0
+	lwi data, rg1
 
     // rg0 is our instruction pointer
     // rg1 is our data pointer
@@ -40,13 +69,6 @@ loop_start:
     // load the current instruction into rg3
     ldb rg0, rg3
 
-
-    // pusha 2
-    // push rg3
-    // call print::print_byte
-    // pop zero
-    // popa 2
-
     // switch on the instruction
     // all cases will return to either loop_start or loop_end
     cmp rg3, rg8
@@ -69,18 +91,14 @@ loop_start:
     jeq end
 
 	// if we get here, we don't know what the instruction is
-    lwi error, rg0
-    push rg0
-    call print::print
-    pop zero
-
-end:
 	lwi error, rg2
     pusha 2
     push rg2
     call print::print
     pop zero
     popa 2
+
+end:
     hlt
 
 loop_end:
@@ -110,7 +128,7 @@ inc_ptr:
 // ------------------------------------------
 // decrement the pointer
 dec_ptr:
-    stw rg1, rg2
+    stw rg2, rg1
     subi rg1, 4
     ldw rg1, rg2
     jmp loop_end

resources/dsa/lib/error/handlers.dsa

@@ -0,0 +1,34 @@
+include print "../io/print.dsa"
+
+dw idt: 0xFFFF0000
+
+setup_idt:
+    push bpr
+    mov spr, bpr
+
+    // load the IDT into the IDR
+	ldw idt, idr
+
+	mov bpr, spr
+	pop bpr
+	irt
+
+setup_hard_fault_handler:
+    push bpr
+    mov spr, bpr
+
+    lwi handle_hard_fault, rg0
+    stw rg0, idr, 4
+
+    mov bpr, spr
+    pop bpr
+    irt
+
+dw hard_fault_err: "FATAL: Illegal Instruction or Memory Access!"
+handle_hard_fault:
+	call print::reset
+	lwi hard_fault_err, rg0
+	push rg0
+	call print::print
+	pop zero
+	hlt

resources/dsa/lib/fib.dsa

@@ -1,18 +0,0 @@
-fib_n:
-    pop ret
-    pop rg0 // n
-
-    lli 0, rg1
-    lli 1, rg2
-    
-start:
-    add rg1, rg2, acc
-    push rg1
-    mov rg2, rg1
-    mov acc, rg2
-    
-    cmp rg0, zero
-    dec rg0
-    
-    jgt start
-    jmp 4, ret

resources/dsa/lib/io/print.dsa

@@ -0,0 +1,244 @@
+// lib:
+// print.dsa
+
+// usage:
+//
+// include print "<relative path>""
+//
+// usage for print:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print::print
+//
+// usage for reset:
+//      push pcx
+//      jmp print::reset
+//
+// usage for clear:
+//      push pcx
+//      jmp print::clear
+//
+// usage for print_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print::print_byte
+//
+// usage for print_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print::print_word
+//
+
+include maths "../maths/core.dsa"
+
+dw display: 0x20000
+dw current: 0x20000
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) to the screen.
+print:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+_print_loop:
+	ldb rg0, acc
+	stb acc, rg1
+
+	addi rg0, 1
+	addi rg1, 1
+
+    cmp acc, zero
+	jne _print_loop
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen.
+print_word:
+    // initialise
+    push bpr
+    mov spr, bpr
+
+    // load byte into acc
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    addi rg1, 3
+
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+
+    addi rg1, 4
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen.
+print_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen in hex.
+print_hex_word:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+
+    ldb bpr, rg0, 8
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 9
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 10
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 11
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen in hex.
+print_hex_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    call _print_hex_byte
+    jmp _end
+
+// function body
+_print_hex_byte:
+    // mask to get lower nibble
+    lli 0xF, rg2
+    // save rg0 state
+    push rg0
+
+    shr rg0, 4
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    pop rg0
+
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    return
+
+// print a hex digit
+_print_hex_nibble:
+    lli 10, rg3
+    cmp rg0, rg3
+    jlt _print_hex_nibble_number
+    addi rg0, 0x37, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// helper function.
+_print_hex_nibble_number:
+    addi rg0, 0x30, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// ------------------------------------------
+// print whitespace
+print_whitespace:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+    lli 0x20, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// print newline
+print_newline:
+    push bpr
+    mov spr, bpr
+
+    // load variables into registers
+    ldw display, rg0
+    ldw current, rg1
+
+    // get the offset from the display base
+    sub rg1, rg0, rg0
+
+    lwi 80, rg2
+    pusha 3
+    push rg0
+    push rg2
+    call maths::divmod
+    pop zero  // result
+    pop rg3 // remainder
+    popa 3
+
+    sub rg1, rg3, rg2
+    addi rg2, 80, rg1
+
+    // _end saves the display state
+    jmp _end
+
+// ------------------------------------------
+// resets the cursor position on the screen to 0x20000. (0,0)
+reset:
+    push bpr
+    mov spr, bpr
+    ldw display, rg1
+    jmp _end
+
+// ------------------------------------------
+// clears the screen
+clear:
+    push bpr
+    mov spr, bpr
+    // display size = 2000 bytes / 500 words
+    lli 500 rg0
+    ldw display, rg1
+
+_clear_loop:
+    dec rg0
+    stw zero, rg1
+    addi rg1, 4
+    cmp rg0, zero
+    jgt _clear_loop
+    jmp _end
+
+// ------------------------------------------
+// return
+_end:
+    stw rg1, current
+
+    mov bpr, spr
+    pop bpr
+    return

resources/dsa/lib/maths/core.dsa

@@ -0,0 +1,60 @@
+// multiply.dsa
+// usage:
+//
+// include multiply "<relative path>"
+//
+// usage for multiply:
+// push (arg1)
+// push (arg0)
+// call multiply::multiply
+// pop (arg0)
+// pop (arg1)
+
+multiply:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg0, 8  // load op 2
+	ldw bpr, rg1, 12 // load op 1
+
+_multiply_loop:
+	add rg2, rg0, rg2
+	dec rg1
+
+	cmp rg1, zero
+	jgt _multiply_loop
+
+_multiply_end:
+	stw rg2, bpr, 8
+
+	mov bpr, spr
+	pop bpr
+	return
+
+divmod:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg1, 8  // load op 2
+	ldw bpr, rg0, 12 // load op 1
+
+	lli 0, rg3
+
+_divmod_loop:
+	cmp rg0, rg1
+	jlt _divmod_end
+
+	sub rg0, rg1, rg0
+	inc rg3
+
+	jmp _divmod_loop
+
+_divmod_end:
+	// store div in first arg
+	// store mod in second arg
+	stw rg3, bpr, 8
+	stw rg0, bpr, 12
+
+	mov bpr, spr
+	pop bpr
+	return

resources/dsa/lib/maths/fib.dsa

@@ -0,0 +1,31 @@
+include print "../io/print.dsa"
+
+fib_n:
+	push bpr
+	mov spr, bpr
+
+	ldw bpr, rg0, 8  // load arg
+    mov rg1, rg2
+    lwi 1, rg1
+
+start:
+    add rg1, rg2, rg3
+
+    pusha 4
+    push rg1
+    call print::print_hex_byte
+    call print::print_newline
+    pop zero
+    popa 4
+
+    mov rg2, rg1
+    mov rg3, rg2
+
+    dec rg0
+    cmp rg0, zero
+    jgt start
+
+    stw rg1, bpr, 8
+    mov bpr, spr
+    pop bpr
+    return

resources/dsa/lib/multiply.dsa

@@ -1,30 +0,0 @@
-// multiply.dsa
-// usage:
-//
-// include multiply "<relative path>"
-//
-// usage for multiply:
-// push (arg1)
-// push (arg0)
-// call multiply::multiply
-// pop (arg0)
-// pop (arg1)
-
-multiply:
-	push bpr
-	mov spr, bpr
-	
-	ldw bpr, rg0, 8  // load op 1
-	ldw bpr, rg1, 12 // load op 2
-
-start:	
-	add acc, rg0, acc
-	dec rg1
-	
-	cmp rg1, zero
-	jgt start
-
-end:
-	mov bpr, spr
-	pop bpr
-	return

resources/dsa/lib/print.dsa

@@ -1,115 +0,0 @@
-// lib:
-// print.dsa
-
-// usage:
-//
-// include print "<relative path>""
-//      
-// usage for print:
-//      push (register containing address of string)
-//      push pcx
-//      jmp print::print
-//
-// usage for reset:
-//      push pcx
-//      jmp print::reset
-//
-// usage for clear:
-//      push pcx
-//      jmp print::clear
-//
-// usage for print_byte:
-//      push (register containing byte)
-//      push pcx
-//      jmp print::print_byte
-//
-// usage for print_word:
-//      push (register containing word)
-//      push pcx
-//      jmp print::print_word
-//
-
-dw display: 0x20000
-dw current: 0x20000
-
-// ------------------------------------------
-// prints the string at addr(arg[0]) to the screen.
-print:
-    push bpr
-    mov spr, bpr
-
-    ldw bpr, rg0, 8
-    ldw current, rg1
-
-_print_loop:
-	ldb rg0, acc
-	stb acc, rg1
-
-	addi rg0, 1
-	addi rg1, 1
-
-    cmp acc, zero
-	jne _print_loop
-    jmp _end
-
-// ------------------------------------------
-// prints the value of arg[0] to the screen.
-print_word:
-    // initialise
-    push bpr
-    mov spr, bpr
-
-    // load byte into acc
-    ldw bpr, rg0, 8
-    ldw current, rg1
-
-    stw rg0, rg1
-    addi rg1, 4
-    jmp _end
-
-// ------------------------------------------
-// prints the last byte of arg[0] to the screen. 
-print_byte:
-    push bpr
-    mov spr, bpr
-
-    ldw bpr, rg0, 8
-    ldw current, rg1
-
-    stb rg0, rg1
-    addi rg1, 1
-    jmp _end
-
-// ------------------------------------------
-// resets the cursor position on the screen to 0x20000. (0,0)
-reset:
-    push bpr
-    mov spr, bpr
-    ldw display, rg1
-    jmp _end
-
-// ------------------------------------------
-// clears the screen
-clear:
-    push bpr
-    mov spr, bpr
-    // display size = 2000 bytes / 500 words
-    lli 500 rg0
-    ldw display, rg1
-
-_clear_loop:
-    dec rg0
-    stw zero, rg1
-    addi rg1, 4
-    cmp rg0, zero
-    jgt _clear_loop
-    jmp _end
-
-// ------------------------------------------
-// return
-_end:
-    stw rg1, current
-	
-    mov bpr, spr
-    pop bpr
-    return

resources/dsa/main.dsa

@@ -0,0 +1,80 @@
+include fib: "./lib/maths/fib.dsa" 
+include maths: "./lib/maths/core.dsa"
+include print: "./lib/io/print.dsa"
+
+dw idt: 0xFFFF0000
+dw stack: 0x10000
+init:
+	// setup interrupt handlers
+	ldw idt, idr
+	lwi handle_hard_fault, rg0
+	stw rg0, idr, 4
+	// set up a stack.
+	ldw stack, bpr
+	mov bpr, spr
+
+dw string: "hello world"
+start:
+
+	lwi 37, rg0
+	lwi 12, rg1
+	push rg0
+	push rg1
+	call maths::divmod
+	pop rg0 // result
+	pop rg1 // remainder
+
+	push rg1
+	push rg0
+	call print::print_hex_byte
+	call print::print_whitespace
+	pop zero
+	call print::print_hex_byte
+	call print::print_newline
+
+	lwi string, rg0
+    //lwi 10, rg0
+    pusha 4
+	push rg0
+	call print::print
+    //call fib::fib_n
+    pop zero
+	call print::print_newline
+	popa 4
+
+	pusha 4
+	push rg0
+	call print::print
+    //call fib::fib_n
+    pop zero
+	call print::print_newline
+	popa 4
+
+	pusha 4
+	push rg0
+	call print::print
+    //call fib::fib_n
+    pop zero
+	call print::print_newline
+	popa 4
+
+	pusha 4
+	push rg0
+	call print::print
+    //call fib::fib_n
+    pop zero
+	call print::print_newline
+	popa 4
+
+    hlt
+
+// fault handler in case we fail DSA.
+dw hard_fault_err: "FATAL: Illegal Instruction or Memory Access!"
+handle_hard_fault:
+	call print::clear
+	call print::reset
+	lwi hard_fault_err, rg0
+	push rg0
+	call print::print
+	pop zero
+	hlt

resources/dsa/test.dsa

@@ -1,18 +0,0 @@
-include print "./lib/print.dsa"
-
-dw stack: 0x10000
-db string: "Hello world"
-
-init:
-	// set up a stack.
-	ldw stack, bpr
-	mov bpr, spr
-
-start:
-	lwi string, rg1
-
-	push rg1
-	call print::print
-	pop rg1
-
-	hlt

resources/dsa/testprint.dsa

@@ -0,0 +1,80 @@
+include print "./lib/io/print.dsa"
+
+dw idt: 0xFFFF0000
+dw stack: 0x10000
+init:
+	// setup interrupt handlers
+	ldw idt, idr
+	lwi handle_hard_fault, rg0
+	stw rg0, idr, 4
+	// set up a stack.
+	ldw stack, bpr
+	mov bpr, spr
+
+
+db string: "I won,  the game!"
+db hexbyte: 0xab
+dw hexword: 0x1234abcd
+db replace: "I lost"
+
+start:
+	// test print string
+	lwi string, rg0
+	push rg0
+	call print::print
+	pop zero
+
+	// test print hex byte.
+	ldb hexbyte, rg0
+	push rg0
+	call print::print_hex_byte
+	pop zero
+
+	// test print hex word.
+	ldw hexword, rg0
+	push rg0
+	call print::print_hex_word
+	pop zero
+
+	// test print char
+	lli 0x40, rg0 // print @
+	push rg0
+	call print::print_byte
+	pop zero
+
+	// test newline
+	call print::print_newline
+
+	lwi string rg0
+	push rg0
+	call print::print
+
+	// test print word
+	lwi 0x31323334, rg0 // print 1234
+	push rg0
+	call print::print_word
+	pop zero
+
+	// test reset cursor pos
+	call print::reset
+	
+	// test print string at reset pos
+	lwi replace, rg0
+	push rg0
+	call print::print
+	pop zero
+
+	hlt
+
+
+
+// fault handler in case we fail DSA.
+dw hard_fault_err: "FATAL: Illegal Instruction or Memory Access!"
+handle_hard_fault:
+	call print::clear
+	call print::reset
+	lwi hard_fault_err, rg0
+	push rg0
+	call print::print
+	pop zero
+	hlt

resources/dsc/example.dsc

@@ -0,0 +1,8 @@
+main: Func = | x: U32, y: U32 | {
+    res = add(x, y);
+    print(res);
+
+    if res > 10 {
+        print("res is greater than 10");
+    }
+}