Labels

Cargo.lock

@@ -35,6 +35,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
 
+[[package]]
+name = "bytemuck"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -101,6 +107,7 @@ name = "hbasm"
 version = "0.1.0"
 dependencies = [
  "ariadne",
+ "bytemuck",
  "hashbrown 0.14.0",
  "hbbytecode",
  "lasso",

hbasm/Cargo.toml

@@ -9,6 +9,7 @@ hbbytecode = { path = "../hbbytecode" }
 literify = "0.1"
 paste = "1.0"
 hashbrown = "0.14.0"
+bytemuck = "1.13.1"
 
 [dependencies.lasso]
 version = "0.7"

hbasm/src/lib.rs

@@ -1,18 +1,20 @@
 #![no_std]
 #![feature(error_in_core)]
 
+use lasso::Key;
+
 extern crate alloc;
 
 pub mod text_r;
 
 mod macros;
 
-use {alloc::vec::Vec, hashbrown::HashSet};
+use {alloc::vec::Vec, hashbrown::HashSet, lasso::Spur};
 
 #[derive(Default)]
 pub struct Assembler {
     pub buf: Vec<u8>,
-    sub:     HashSet<usize>,
+    pub sub: HashSet<usize>,
 }
 
 macros::impl_both!(
@@ -53,11 +55,11 @@ macro_rules! impl_imm_le_bytes {
 impl_imm_le_bytes!(u64, i64, f64);
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Symbol(pub u64);
+struct Symbol(pub Spur);
 impl Imm for Symbol {
     #[inline(always)]
     fn insert(&self, asm: &mut Assembler) {
         asm.sub.insert(asm.buf.len());
-        asm.buf.extend(self.0.to_le_bytes());
+        asm.buf.extend((self.0.into_usize() as u64).to_le_bytes());
     }
 }

hbasm/src/macros/text.rs

@@ -12,7 +12,8 @@ macro_rules! gen_text {
                     Assembler,
                     macros::text::*,
                 },
-                lasso::{Rodeo, Spur},
+                hashbrown::HashMap,
+                lasso::{Key, Rodeo, Spur},
                 logos::{Lexer, Logos, Span},
             };
 
@@ -72,8 +73,15 @@ macro_rules! gen_text {
             }
 
             pub fn assemble(asm: &mut Assembler, code: &str) -> Result<(), Error> {
-                fn next(lexer: &mut Lexer<Token>) -> Result<Token, ErrorKind> {
+                pub struct TextAsm<'a> {
-                    match lexer.next() {
+                    asm: &'a mut Assembler,
+                    lexer: Lexer<'a, Token>,
+                    symloc: HashMap<Spur, usize>,
+                }
+
+                impl<'a> TextAsm<'a> {
+                    fn next(&mut self) -> Result<Token, ErrorKind> {
+                        match self.lexer.next() {
                             Some(Ok(t))   => Ok(t),
                             Some(Err(())) => Err(ErrorKind::InvalidToken),
                             None          => Err(ErrorKind::UnexpectedEnd),
@@ -81,22 +89,22 @@ macro_rules! gen_text {
                     }
 
                     #[inline(always)]
-                fn inner(asm: &mut Assembler, lexer: &mut Lexer<Token>) -> Result<(), ErrorKind> {
+                    fn run(&mut self) -> Result<(), ErrorKind> {
                         loop {
-                        match lexer.next() {
+                            match self.lexer.next() {
                                 Some(Ok(Token::Opcode(op))) => {
                                     match op {
                                         $(
                                             $(hbbytecode::opcode::$opcode)|* => paste::paste!({
-                                            param_extract_itm!(lexer, $($param_i: $param_ty),*);
+                                                param_extract_itm!(self, $($param_i: $param_ty),*);
-                                            asm.[<i_param_ $ityn>](op, $($param_i),*);
+                                                self.asm.[<i_param_ $ityn>](op, $($param_i),*);
                                             }),
                                         )*
                                         _ => unreachable!(),
                                     }
                                 }
-                            Some(Ok(Token::Label(_))) => {
+                                Some(Ok(Token::Label(lbl))) => {
-                                todo!("Labels");
+                                    self.symloc.insert(lbl, self.asm.buf.len());
                                 }
                                 Some(Ok(Token::ISep)) => (),
                                 Some(Ok(_))           => return Err(ErrorKind::UnexpectedToken),
@@ -105,42 +113,84 @@ macro_rules! gen_text {
                             }
                         }
                     }
+                }
 
-                let mut lexer = Token::lexer(code);
+                let mut asm = TextAsm {
-                inner(asm, &mut lexer)
+                    asm,
-                    .map_err(|kind| Error { kind, span: lexer.span() })
+                    lexer: Token::lexer(code),
+                    symloc: HashMap::default(),
+                };
+
+                asm.run()
+                    .map_err(|kind| Error { kind, span: asm.lexer.span() })?;
+                for &loc in &asm.asm.sub {
+                    let val = asm.symloc
+                        .get(
+                            &Spur::try_from_usize(bytemuck::pod_read_unaligned::<u64>(&asm.asm.buf[loc..loc+core::mem::size_of::<u64>()]) as _)
+                                .unwrap()
+                        )
+                        .ok_or(Error { kind: ErrorKind::InvalidSymbol, span: 0..0 })?
+                        .to_le_bytes();
+
+                    asm.asm.buf[loc..]
+                        .iter_mut()
+                        .zip(val)
+                        .for_each(|(dst, src)| *dst = src);
+                }
+
+                Ok(())
+            }
+
+            enum InternalImm {
+                Const(u64),
+                Named(Spur),
+            }
+
+            impl $crate::Imm for InternalImm {
+                #[inline]
+                fn insert(&self, asm: &mut Assembler) {
+                    match self {
+                        Self::Const(a) => a.insert(asm),
+                        Self::Named(a) => $crate::Symbol(*a).insert(asm),
+                    }
+                }
             }
         }
     };
 }
 
 macro_rules! extract_pat {
-    ($lexer:expr, $pat:pat) => {
+    ($self:expr, $pat:pat) => {
-        let $pat = next($lexer)?
+        let $pat = $self.next()?
                                     else { return Err(ErrorKind::UnexpectedToken) };
     };
 }
 
 macro_rules! extract {
-    ($lexer:expr, R, $id:ident) => {
+    ($self:expr, R, $id:ident) => {
-        extract_pat!($lexer, Token::Register($id));
+        extract_pat!($self, Token::Register($id));
     };
-    ($lexer:expr, I, $id:ident) => {
+
-        extract_pat!($lexer, Token::Integer($id));
+    ($self:expr, I, $id:ident) => {
+        let $id = match $self.next()? {
+            Token::Integer(a) => InternalImm::Const(a),
+            Token::Symbol(a) => InternalImm::Named(a),
+            _ => return Err(ErrorKind::UnexpectedToken),
         };
-    ($lexer:expr, u16, $id:ident) => {
+    };
-        extract_pat!($lexer, Token::Integer($id));
+
-        let $id = u16::try_from($id)
+    ($self:expr, u16, $id:ident) => {
-            .map_err(|_| ErrorKind::InvalidToken)?;
+        extract_pat!($self, Token::Integer($id));
+        let $id = u16::try_from($id).map_err(|_| ErrorKind::InvalidToken)?;
     };
 }
 
 macro_rules! param_extract_itm {
-    ($lexer:expr, $($id:ident: $ty:ident)? $(, $($tt:tt)*)?) => {
+    ($self:expr, $($id:ident: $ty:ident)? $(, $($tt:tt)*)?) => {
-        $(extract!($lexer, $ty, $id);)?
+        $(extract!($self, $ty, $id);)?
         $(
-            extract_pat!($lexer, Token::PSep);
+            extract_pat!($self, Token::PSep);
-            param_extract_itm!($lexer, $($tt)*);
+            param_extract_itm!($self, $($tt)*);
         )?
     };
 }

hbasm/src/main.rs

@@ -1,3 +1,5 @@
+use std::io::Write;
+
 use hbasm::Assembler;
 
 use {
@@ -25,8 +27,12 @@ fn main() -> Result<(), Box<dyn Error>> {
         let message = match e.kind {
             hbasm::text::ErrorKind::UnexpectedToken => "This token is not expected!",
             hbasm::text::ErrorKind::InvalidToken => "The token is not valid!",
-            hbasm::text::ErrorKind::UnexpectedEnd => "The assembler reached the end of input unexpectedly!",
+            hbasm::text::ErrorKind::UnexpectedEnd => {
-            hbasm::text::ErrorKind::InvalidSymbol => "This referenced symbol doesn't have a corresponding label!",
+                "The assembler reached the end of input unexpectedly!"
+            }
+            hbasm::text::ErrorKind::InvalidSymbol => {
+                "This referenced symbol doesn't have a corresponding label!"
+            }
         };
         let a = colors.next();
 
@@ -41,6 +47,8 @@ fn main() -> Result<(), Box<dyn Error>> {
             .finish()
             .eprint(("engine_internal", Source::from(&code)))
             .unwrap();
+    } else {
+        std::io::stdout().lock().write_all(&assembler.buf).unwrap();
     }
 
     Ok(())