IT WORKS HELL YEAH.

assembler/src/lib.rs

@@ -9,10 +9,11 @@ use std::{
 use common::prelude::Instruction;
 
 use crate::{
+    codegen::codegen,
     expand::expand_pseudo_ops,
     model::{Node, Symbol, Token, TokenType},
     parser::{Parser, Program},
-    resolver::{resolve_dependencies, resolve_symbols},
+    resolver::{create_sections, resolve_dependencies, resolve_symbols},
 };
 
 pub mod codegen;
@@ -22,26 +23,25 @@ pub mod model;
 pub mod parser;
 pub mod resolver;
 
-pub fn assemble(src: &Path) -> Vec<Instruction> {
+pub fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
     let mut modules = HashSet::<u64>::new();
     let mut program = Program::new();
 
     let hash = quick_hash(src);
     modules.insert(hash);
 
-    match prepare_dependency(src, &mut modules, &mut program) {
-        Ok(_) => {}
-        Err(err) => println!("BIG ERROR {err:?}"),
-    }
-
+    prepare_dependency(src, &mut modules, &mut program)?;
     let mut nodes = program.nodes;
-    resolve_symbols(&mut nodes).unwrap();
 
-    for node in nodes {
-        println!("{node}");
+    create_sections(&mut nodes)?;
+    resolve_symbols(&mut nodes)?;
+
+    let instructions = codegen(nodes)?;
+    for inst in instructions.iter() {
+        println!("{}", inst);
     }
 
-    vec![]
+    Ok(instructions)
 }
 
 fn prepare_dependency(
@@ -71,6 +71,7 @@ fn prepare_dependency(
 
     log(&format!("{:20} {:20}", "Resolving Deps", filename));
     let nodes = resolve_dependencies(parsed)?;
+
     let deps = Parser::get_dependencies(&nodes)?;
 
     log(&format!(
@@ -79,6 +80,10 @@ fn prepare_dependency(
     ));
     let nodes = expand_pseudo_ops(nodes, file_hash)?;
 
+    for n in nodes.iter() {
+        println!("{}", n);
+    }
+
     program.add_module(nodes);
 
     for dep in deps {