fixed a lot of bugs with the emulator, instruction set and assembler

assembler/src/codegen.rs

@@ -22,8 +22,6 @@ fn build_instruction(node: Node) -> Result<Instruction, AssembleError> {
     let opcode = node.opcode();
     let args = node.args();
 
-    // println!("{node}");
-
     match opcode {
         Opcode::Nop => Ok(Instruction::Nop),
         Opcode::Mov => {

assembler/src/expand.rs

@@ -29,14 +29,11 @@ fn try_expand(
     match node.opcode() {
         Opcode::Push => expand_push(node.clone(), result)?,
         Opcode::Pop => expand_pop(node.clone(), result)?,
-        Opcode::Ldb
-        | Opcode::Ldbs
-        | Opcode::Ldh
-        | Opcode::Ldhs
-        | Opcode::Ldw
-        | Opcode::Stb
-        | Opcode::Sth
-        | Opcode::Stw => expand_ldx(node.clone(), result)?,
+        Opcode::Ldb | Opcode::Ldbs | Opcode::Ldh | Opcode::Ldhs | Opcode::Ldw => {
+            expand_ldx(node.clone(), result)?
+        }
+        Opcode::Stb | Opcode::Sth | Opcode::Stw => expand_stx(node.clone(), result)?,
+
         Opcode::Lwi => expand_lwi(node.clone(), result)?,
         Opcode::Resb | Opcode::Resh | Opcode::Resw => expand_resx(node.clone(), result)?,
         Opcode::Db | Opcode::Dh | Opcode::Dw => expand_dx(node.clone(), result)?,
@@ -52,10 +49,10 @@ fn expand_push(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError
     nodes.extend(vec![
         node!(
             label,
-            Opcode::Iadd,
-            reg.clone(),
+            Opcode::Isub,
+            Token::Register(Register::Spr),
             Token::Immediate(4),
-            reg.clone()
+            Token::Register(Register::Spr)
         ),
         node!(
             None,
@@ -76,17 +73,17 @@ fn expand_pop(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError>
     nodes.extend(vec![
         node!(
             label,
-            Opcode::Isub,
-            reg.clone(),
-            Token::Immediate(4),
-            reg.clone()
+            Opcode::Ldw,
+            Token::Register(Register::Spr),
+            reg,
+            Token::Immediate(0)
         ),
         node!(
             None,
-            Opcode::Ldw,
-            reg,
+            Opcode::Iadd,
             Token::Register(Register::Spr),
-            Token::Immediate(0)
+            Token::Immediate(4),
+            Token::Register(Register::Spr)
         ),
     ]);
 
@@ -108,6 +105,30 @@ fn expand_ldx(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError>
     Ok(())
 }
 
+fn expand_stx(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError> {
+    let opcode = current.opcode();
+    let base = expect_type!(current.arg(0).unwrap(), Register)?;
+    let dest = expect_type!(current.arg(1).unwrap(), Symbol)?;
+    let offset = expect_type!(current.arg(2).unwrap(), Immediate)?;
+    nodes.extend(vec![
+        node!(
+            current.label(),
+            Opcode::Lli,
+            dest.clone(),
+            Token::Register(Register::Rgf)
+        ),
+        node!(
+            None,
+            Opcode::Lui,
+            dest.clone(),
+            Token::Register(Register::Rgf)
+        ),
+        node!(None, opcode, base, Token::Register(Register::Rgf), offset),
+    ]);
+
+    Ok(())
+}
+
 fn expand_lwi(current: Node, nodes: &mut Vec<Node>) -> Result<(), AssembleError> {
     let val = expect_type!(current.arg(0).unwrap(), Symbol, Immediate)?;
     let reg = expect_type!(current.arg(1).unwrap(), Register)?;
@@ -174,7 +195,8 @@ fn process_dx_data(args: Vec<Token>, size: usize) -> Result<Vec<u32>, AssembleEr
     // Process each token
     for token in args {
         match token {
-            Token::StringLit(s) => {
+            Token::StringLit(mut s) => {
+                s.push('\0');
                 // Split string into chars and write as bytes
                 for ch in s.chars() {
                     // Convert char to bytes (UTF-8 encoding)

assembler/src/lib.rs

@@ -11,7 +11,7 @@ use common::prelude::Instruction;
 use crate::{
     codegen::codegen,
     expand::expand_pseudo_ops,
-    model::{Node, Symbol, Token, TokenType},
+    model::{Node, Opcode, Symbol, Token, TokenType},
     parser::{Parser, Program},
     resolver::{create_sections, resolve_dependencies, resolve_symbols},
 };
@@ -78,7 +78,13 @@ fn prepare_dependency(
         "{:20} {:20}",
         "Expanding PseudoInstructions", filename
     ));
-    let nodes = expand_pseudo_ops(nodes, file_hash)?;
+    let mut nodes = expand_pseudo_ops(nodes, file_hash)?;
+
+    // add a section instruction
+    nodes.insert(
+        0,
+        node!(None, Opcode::Segment, Token::Immediate(file_hash as u32)),
+    );
 
     for n in nodes.iter() {
         println!("{}", n);

assembler/src/parser.rs

@@ -87,14 +87,7 @@ impl Parser {
                 args = vec![reg1, reg2];
             }
 
-            Opcode::Ldb
-            | Opcode::Ldbs
-            | Opcode::Ldh
-            | Opcode::Ldhs
-            | Opcode::Ldw
-            | Opcode::Stb
-            | Opcode::Sth
-            | Opcode::Stw => {
+            Opcode::Ldb | Opcode::Ldbs | Opcode::Ldh | Opcode::Ldhs | Opcode::Ldw => {
                 let base = expect_type!(self.next()?, Register, Symbol)?;
                 let dest = expect_type!(self.next()?, Register)?;
 
@@ -107,6 +100,17 @@ impl Parser {
 
                 args = vec![base, dest, offset];
             }
+            Opcode::Stb | Opcode::Sth | Opcode::Stw => {
+                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 let Ok(_) = expect_type!(next, Immediate) {
+                        offset = self.next()?;
+                    }
+                }
+                args = vec![base, dest, offset];
+            }
 
             Opcode::Add
             | Opcode::Sub

assembler/src/resolver.rs

@@ -133,7 +133,6 @@ pub fn create_sections(nodes: &mut Vec<Node>) -> Result<(), AssembleError> {
         }
     }
 
-    res.push(node!(None, Opcode::Segment, Token::Immediate(1)));
     let start = res.len() + 1;
     res.insert(
         0,