adding target @target directive

Signed-off-by: Jakub Doka <jakub.doka2@gmail.com>

.cargo/config.toml

@@ -1,2 +1,4 @@
 [alias]
 xtask = "r -p xtask --"
+wasm-build = "b --target wasm32-unknown-unknown --profile=small -Zbuild-std=core,alloc -Zbuild-std-features=optimize_for_size,panic_immediate_abort -p"
+wasm-build-debug = "b --target wasm32-unknown-unknown --profile=small-dev -Zbuild-std=core,alloc -Zbuild-std-features=optimize_for_size -p"

.gitignore

@@ -1,4 +1,19 @@
+# garbage
 /target
-/hbbytecode/src/instrs.rs
-/.rgignore
 rustc-ice-*
+
+a.out
+out.o
+/examples/raylib/main
+
+# sqlite
+db.sqlite
+db.sqlite-journal
+
+# assets
+/depell/src/*.gz
+/depell/src/*.wasm
+/depell/src/static-pages/*.html
+#**/*-sv.rs
+/bytecode/src/instrs.rs
+/lang/src/testcases.rs

Cargo.toml

@@ -1,17 +1,50 @@
+cargo-features = ["profile-rustflags"]
+
 [workspace]
 resolver = "2"
-members = ["hbbytecode", "hbvm", "hbxrt", "xtask", "hblang", "hbjit"]
+members = [
+	"bytecode",
+	"vm",
+	"xrt",
+	"xtask",
+	"lang",
+	"depell",
+	"depell/wasm-fmt",
+	"depell/wasm-hbc",
+	"depell/wasm-rt",
+	"cranelift-backend",
+	"c",
+]
+
+[workspace.dependencies]
+hbbytecode = { path = "bytecode", default-features = false }
+hbvm = { path = "vm", default-features = false }
+hblang = { path = "lang", default-features = false }
 
 [profile.release]
-strip = true
 lto = true
+#debug = true
+strip = true
 codegen-units = 1
 panic = "abort"
 
 [profile.small]
+rustflags = ["-Zfmt-debug=none", "-Zlocation-detail=none"]
 inherits = "release"
 opt-level = "z"
-strip = true
+strip = "debuginfo"
 lto = true
 codegen-units = 1
 panic = "abort"
+
+[profile.small-dev]
+inherits = "dev"
+opt-level = "z"
+strip = "debuginfo"
+panic = "abort"
+
+[profile.fuzz]
+inherits = "dev"
+debug = true
+opt-level = 3
+panic = "abort"

bytecode/Cargo.toml

@@ -5,5 +5,6 @@ edition = "2018"
 
 [features]
 default = ["disasm"]
-std = []
-disasm = ["std"]
+disasm = ["alloc"]
+alloc = []
+

bytecode/build.rs

@@ -14,7 +14,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn gen_instrs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
-    writeln!(generated, "#![allow(dead_code)] #![allow(clippy::upper_case_acronyms)]")?;
+    writeln!(generated, "#![expect(dead_code)]")?;
     writeln!(generated, "use crate::*;")?;
 
     '_opcode_structs: {
@@ -85,11 +85,7 @@ fn gen_instrs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>>
     }
 
     '_name_list: {
-        writeln!(generated, "pub const NAMES: [&str; {}] = [", instructions().count())?;
-        for [_, name, _, _] in instructions() {
-            writeln!(generated, "    \"{}\",", name.to_lowercase())?;
-        }
-        writeln!(generated, "];")?;
+        writeln!(generated, "pub const COUNT: u8 = {};", instructions().count())?;
     }
 
     let instr = "Instr";
@@ -102,6 +98,27 @@ fn gen_instrs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>>
             writeln!(generated, "    {name} = {id},")?;
         }
         writeln!(generated, "}}")?;
+
+        writeln!(generated, "impl {instr} {{")?;
+        writeln!(generated, "    pub fn size(self) -> usize {{")?;
+        writeln!(generated, "        match self {{")?;
+        let mut instrs = instructions().collect::<Vec<_>>();
+        instrs.sort_unstable_by_key(|&[.., ty, _]| iter_args(ty).map(arg_to_width).sum::<usize>());
+        for group in instrs.chunk_by(|[.., a, _], [.., b, _]| {
+            iter_args(a).map(arg_to_width).sum::<usize>()
+                == iter_args(b).map(arg_to_width).sum::<usize>()
+        }) {
+            let ty = group[0][2];
+            for &[_, name, ..] in group {
+                writeln!(generated, "            | {instr}::{name}")?;
+            }
+            generated.pop();
+            let size = iter_args(ty).map(arg_to_width).sum::<usize>() + 1;
+            writeln!(generated, " => {size},")?;
+        }
+        writeln!(generated, "        }}")?;
+        writeln!(generated, "    }}")?;
+        writeln!(generated, "}}")?;
     }
 
     '_arg_kind: {
@@ -123,7 +140,7 @@ fn gen_instrs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>>
             "/// This assumes the instruction byte is still at the beginning of the buffer"
         )?;
         writeln!(generated, "#[cfg(feature = \"disasm\")]")?;
-        writeln!(generated, "pub fn parse_args(bytes: &mut &[u8], kind: {instr}, buf: &mut std::vec::Vec<{oper}>) -> Option<()> {{")?;
+        writeln!(generated, "pub fn parse_args(bytes: &mut &[u8], kind: {instr}, buf: &mut alloc::vec::Vec<{oper}>) -> Option<()> {{")?;
         writeln!(generated, "    match kind {{")?;
         let mut instrs = instructions().collect::<Vec<_>>();
         instrs.sort_unstable_by_key(|&[.., ty, _]| ty);
@@ -163,7 +180,7 @@ fn comma_sep(items: impl Iterator<Item = String>) -> String {
 }
 
 fn instructions() -> impl Iterator<Item = [&'static str; 4]> {
-    include_str!("../hbbytecode/instructions.in")
+    include_str!("instructions.in")
         .lines()
         .filter_map(|line| line.strip_suffix(';'))
         .map(|line| line.splitn(4, ',').map(str::trim).next_chunk().unwrap())

bytecode/src/lib.rs

@@ -1,7 +1,7 @@
 #![no_std]
 
-#[cfg(feature = "std")]
-extern crate std;
+#[cfg(feature = "disasm")]
+extern crate alloc;
 
 pub use crate::instrs::*;
 use core::convert::TryFrom;
@@ -34,8 +34,8 @@ impl TryFrom<u8> for Instr {
             Err(value)
         }
 
-        if value < NAMES.len() as u8 {
-            unsafe { Ok(std::mem::transmute::<u8, Instr>(value)) }
+        if value < COUNT {
+            unsafe { Ok(core::mem::transmute::<u8, Instr>(value)) }
         } else {
             failed(value)
         }
@@ -50,8 +50,9 @@ unsafe fn encode<T>(instr: T) -> (usize, [u8; instrs::MAX_SIZE]) {
 }
 
 #[inline]
+#[cfg(feature = "disasm")]
 fn decode<T>(binary: &mut &[u8]) -> Option<T> {
-    let (front, rest) = std::mem::take(binary).split_at_checked(core::mem::size_of::<T>())?;
+    let (front, rest) = core::mem::take(binary).split_at_checked(core::mem::size_of::<T>())?;
     *binary = rest;
     unsafe { Some(core::ptr::read(front.as_ptr() as *const T)) }
 }
@@ -82,41 +83,74 @@ pub enum DisasmItem {
 }
 
 #[cfg(feature = "disasm")]
-pub fn disasm(
+#[derive(Debug)]
+pub enum DisasmError<'a> {
+    InvalidInstruction(u8),
+    InstructionOutOfBounds(&'a str),
+    FmtFailed(core::fmt::Error),
+    HasOutOfBoundsJumps,
+}
+
+#[cfg(feature = "disasm")]
+impl From<core::fmt::Error> for DisasmError<'_> {
+    fn from(value: core::fmt::Error) -> Self {
+        Self::FmtFailed(value)
+    }
+}
+
+#[cfg(feature = "disasm")]
+impl core::fmt::Display for DisasmError<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match *self {
+            DisasmError::InvalidInstruction(b) => write!(f, "invalid instruction opcode: {b}"),
+            DisasmError::InstructionOutOfBounds(name) => {
+                write!(f, "instruction would go out of bounds of {name} symbol")
+            }
+            DisasmError::FmtFailed(error) => write!(f, "fmt failed: {error}"),
+            DisasmError::HasOutOfBoundsJumps => write!(
+                f,
+                "the code contained jumps that dont got neither to a \
+                valid symbol or local insturction"
+            ),
+        }
+    }
+}
+
+#[cfg(feature = "disasm")]
+impl core::error::Error for DisasmError<'_> {}
+
+#[cfg(feature = "disasm")]
+pub fn disasm<'a>(
     binary: &mut &[u8],
-    functions: &std::collections::BTreeMap<u32, (&str, u32, DisasmItem)>,
-    out: &mut impl std::io::Write,
+    functions: &alloc::collections::BTreeMap<u32, (&'a str, u32, DisasmItem)>,
+    out: &mut alloc::string::String,
     mut eca_handler: impl FnMut(&mut &[u8]),
-) -> std::io::Result<()> {
+) -> Result<(), DisasmError<'a>> {
     use {
         self::instrs::Instr,
-        std::{
-            collections::{hash_map::Entry, HashMap},
-            convert::TryInto,
+        alloc::{
+            collections::btree_map::{BTreeMap, Entry},
             vec::Vec,
         },
+        core::{convert::TryInto, fmt::Write},
     };
 
-    fn instr_from_byte(b: u8) -> std::io::Result<Instr> {
-        if b as usize >= instrs::NAMES.len() {
-            return Err(std::io::ErrorKind::InvalidData.into());
-        }
-        Ok(unsafe { std::mem::transmute::<u8, Instr>(b) })
+    fn instr_from_byte(b: u8) -> Result<Instr, DisasmError<'static>> {
+        b.try_into().map_err(DisasmError::InvalidInstruction)
     }
 
-    let mut labels = HashMap::<u32, u32>::default();
+    let mut labels = BTreeMap::<u32, u32>::default();
     let mut buf = Vec::<instrs::Oper>::new();
-    let mut has_cycle = false;
     let mut has_oob = false;
 
-    '_offset_pass: for (&off, &(_name, len, kind)) in functions.iter() {
+    '_offset_pass: for (&off, &(name, len, kind)) in functions.iter() {
         if matches!(kind, DisasmItem::Global) {
             continue;
         }
 
         let prev = *binary;
 
-        *binary = &binary[..off as usize];
+        *binary = &binary[off as usize..];
 
         let mut label_count = 0;
         while let Some(&byte) = binary.first() {
@@ -125,7 +159,8 @@ pub fn disasm(
                 break;
             }
             let Ok(inst) = instr_from_byte(byte) else { break };
-            instrs::parse_args(binary, inst, &mut buf).ok_or(std::io::ErrorKind::OutOfMemory)?;
+            instrs::parse_args(binary, inst, &mut buf)
+                .ok_or(DisasmError::InstructionOutOfBounds(name))?;
 
             for op in buf.drain(..) {
                 let rel = match op {
@@ -134,8 +169,6 @@ pub fn disasm(
                     _ => continue,
                 };
 
-                has_cycle |= rel == 0;
-
                 let global_offset: u32 = (offset + rel).try_into().unwrap();
                 if functions.get(&global_offset).is_some() {
                     continue;
@@ -168,7 +201,7 @@ pub fn disasm(
 
         writeln!(out, "{name}:")?;
 
-        *binary = &binary[..off as usize];
+        *binary = &binary[off as usize..];
         while let Some(&byte) = binary.first() {
             let offset: i32 = (prev.len() - binary.len()).try_into().unwrap();
             if offset as u32 == off + len {
@@ -219,8 +252,9 @@ pub fn disasm(
                 } else {
                     let local_has_oob = global_offset < off
                         || global_offset > off + len
-                        || instr_from_byte(prev[global_offset as usize]).is_err()
-                        || prev[global_offset as usize] == 0;
+                        || prev
+                            .get(global_offset as usize)
+                            .is_none_or(|&b| instr_from_byte(b).is_err());
                     has_oob |= local_has_oob;
                     let label = labels.get(&global_offset).unwrap();
                     if local_has_oob {
@@ -242,11 +276,7 @@ pub fn disasm(
     }
 
     if has_oob {
-        return Err(std::io::ErrorKind::InvalidInput.into());
-    }
-
-    if has_cycle {
-        return Err(std::io::ErrorKind::TimedOut.into());
+        return Err(DisasmError::HasOutOfBoundsJumps);
     }
 
     Ok(())

c/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "hbc"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+clap = { version = "4.5.23", features = ["derive", "env"] }
+cranelift-backend = { version = "0.1.0", path = "../cranelift-backend" }
+hblang = { workspace = true, features = ["std"] }
+log = "0.4.22"
+target-lexicon = { version = "0.12", features = ["std"] }

c/src/main.rs

@@ -0,0 +1,95 @@
+use {
+    clap::Parser,
+    std::{io, str::FromStr},
+};
+
+#[derive(Parser)]
+struct Args {
+    /// format depends on the backend used
+    /// - cranelift-backend expects `<key>=<value>,...` pass `help=me` to see options
+    #[clap(long, env, default_value = "")]
+    backend_flags: String,
+    #[clap(long, short, env, default_value_t = target_lexicon::HOST)]
+    target: target_lexicon::Triple,
+    #[clap(long, env, value_parser = ["ableos"])]
+    path_resolver: Option<String>,
+    /// format the source code reachable form the root file
+    #[clap(long, env, default_value_t = false, conflicts_with_all = &["fmt_stdout", "dump_asm"])]
+    fmt: bool,
+    /// format the root file only and output the formatted file into stdout
+    #[clap(long, env, default_value_t = false, conflicts_with_all = &["fmt", "dump_asm"])]
+    fmt_stdout: bool,
+    #[clap(long, env, default_value_t = false, conflicts_with_all = &["fmt", "fmt_stdout"])]
+    dump_asm: bool,
+    /// extra threads to be used during compilation (currently only parser is parallelized)
+    #[clap(long, env, default_value_t = 0)]
+    extra_threads: usize,
+    /// path to the root file
+    file: String,
+}
+
+fn main() {
+    use std::io::Write;
+
+    fn run(out: &mut Vec<u8>, warnings: &mut String) -> std::io::Result<()> {
+        let Args {
+            backend_flags,
+            target,
+            path_resolver,
+            fmt,
+            fmt_stdout,
+            dump_asm,
+            extra_threads,
+            file,
+        } = Args::parse();
+
+        let resolvers = &[("ableos", hblang::ABLEOS_PATH_RESOLVER)];
+
+        let mut native = None;
+        let backend = if target
+            == target_lexicon::Triple::from_str(hblang::backend::hbvm::TARGET_TRIPLE).unwrap()
+        {
+            None
+        } else {
+            Some(
+                native.insert(
+                    cranelift_backend::Backend::new(target, &backend_flags)
+                        .map_err(io::Error::other)?,
+                ) as &mut dyn hblang::backend::Backend,
+            )
+        };
+
+        let opts = hblang::Options {
+            fmt,
+            fmt_stdout,
+            dump_asm,
+            extra_threads,
+            resolver: resolvers
+                .iter()
+                .copied()
+                .find(|&(name, _)| Some(name) == path_resolver.as_deref())
+                .map(|(_, v)| v),
+            backend,
+        };
+
+        hblang::run_compiler(&file, opts, out, warnings)
+    }
+
+    log::set_logger(&hblang::fs::Logger).unwrap();
+    log::set_max_level(log::LevelFilter::Error);
+
+    let mut out = Vec::new();
+    let mut warnings = String::new();
+    match run(&mut out, &mut warnings) {
+        Ok(_) => {
+            std::io::stderr().write_all(warnings.as_bytes()).unwrap();
+            std::io::stdout().write_all(&out).unwrap()
+        }
+        Err(e) => {
+            std::io::stderr().write_all(warnings.as_bytes()).unwrap();
+            std::io::stderr().write_all(&out).unwrap();
+            std::eprint!("{e}");
+            std::process::exit(1);
+        }
+    }
+}

cranelift-backend/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "cranelift-backend"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+cranelift-codegen = "0.115.0"
+cranelift-frontend = "0.115.0"
+cranelift-module = "0.115.0"
+cranelift-object = "0.115.0"
+hblang.workspace = true
+target-lexicon = "0.12"

cranelift-backend/src/lib.rs

@@ -0,0 +1,994 @@
+#![feature(if_let_guard)]
+#![feature(slice_take)]
+use {
+    core::panic,
+    cranelift_codegen::{
+        self as cc, CodegenError, Final, FinalizedMachReloc, MachBufferFinalized,
+        ir::{self as cir, InstBuilder, MemFlags, TrapCode, UserExternalName, condcodes},
+        isa::{LookupError, TargetIsa},
+        settings::{Configurable, SetError},
+    },
+    cranelift_frontend::{self as cf, FunctionBuilder},
+    cranelift_module::{self as cm, Module, ModuleError},
+    hblang::{
+        lexer::TokenKind,
+        nodes::{self as hbnodes},
+        ty as hbty,
+        utils::{self as hbutils, Ent, EntVec},
+    },
+    std::{
+        collections::HashSet,
+        fmt::{Display, Write},
+        ops::Range,
+    },
+};
+
+mod x86_64;
+
+pub struct Backend {
+    ctx: cc::Context,
+    dt_ctx: cm::DataDescription,
+    fb_ctx: cf::FunctionBuilderContext,
+    module: Option<cranelift_object::ObjectModule>,
+    ctrl_plane: cc::control::ControlPlane,
+    funcs: Functions,
+    globals: EntVec<hbty::Global, Global>,
+    asm: Assembler,
+}
+
+impl Backend {
+    pub fn new(triple: target_lexicon::Triple, flags: &str) -> Result<Self, BackendCreationError> {
+        Ok(Self {
+            ctx: cc::Context::new(),
+            dt_ctx: cm::DataDescription::new(),
+            fb_ctx: cf::FunctionBuilderContext::default(),
+            ctrl_plane: cc::control::ControlPlane::default(),
+            module: cranelift_object::ObjectModule::new(cranelift_object::ObjectBuilder::new(
+                cc::isa::lookup(triple)?.finish(cc::settings::Flags::new({
+                    let mut bl = cc::settings::builder();
+                    for (k, v) in flags.split(',').filter_map(|s| s.split_once('=')) {
+                        bl.set(k, v).map_err(|err| BackendCreationError::InvalidFlag {
+                            key: k.to_owned(),
+                            value: v.to_owned(),
+                            err,
+                        })?;
+                    }
+                    bl
+                }))?,
+                "main",
+                cm::default_libcall_names(),
+            )?)
+            .into(),
+            funcs: Default::default(),
+            globals: Default::default(),
+            asm: Default::default(),
+        })
+    }
+}
+
+impl hblang::backend::Backend for Backend {
+    fn triple(&self) -> String {
+        self.module.as_ref().unwrap().isa().triple().to_string()
+    }
+
+    fn assemble_reachable(
+        &mut self,
+        from: hbty::Func,
+        types: &hbty::Types,
+        files: &hbutils::EntSlice<hbty::Module, hblang::parser::Ast>,
+        to: &mut Vec<u8>,
+    ) -> hblang::backend::AssemblySpec {
+        debug_assert!(self.asm.frontier.is_empty());
+        debug_assert!(self.asm.funcs.is_empty());
+        debug_assert!(self.asm.globals.is_empty());
+
+        let mut module = self.module.take().expect("backend can assemble only once");
+
+        fn clif_name_to_ty(name: UserExternalName) -> hbty::Id {
+            match name.namespace {
+                0 => hbty::Kind::Func(hbty::Func::new(name.index as _)),
+                1 => hbty::Kind::Global(hbty::Global::new(name.index as _)),
+                _ => unreachable!(),
+            }
+            .compress()
+        }
+
+        self.globals.shadow(types.ins.globals.len());
+
+        let mut seen_names = HashSet::new();
+
+        self.asm.frontier.push(from.into());
+        while let Some(itm) = self.asm.frontier.pop() {
+            match itm.expand() {
+                hbty::Kind::Func(func) => {
+                    let fd = &types.ins.funcs[func];
+                    if fd.is_import {
+                        self.funcs.headers.shadow(func.index() + 1);
+                    }
+                    let fuc = &mut self.funcs.headers[func];
+                    let file = &files[fd.file];
+                    if fuc.module_id.is_some() {
+                        continue;
+                    }
+                    self.asm.frontier.extend(
+                        fuc.external_names.clone().map(|r| {
+                            clif_name_to_ty(self.funcs.external_names[r as usize].clone())
+                        }),
+                    );
+                    self.asm.name.clear();
+                    if func == from {
+                        self.asm.name.push_str("main");
+                    } else if fd.is_import {
+                        self.asm.name.push_str(file.ident_str(fd.name));
+                    } else {
+                        self.asm.name.push_str(hblang::strip_cwd(&file.path));
+                        self.asm.name.push('.');
+                        if fd.parent != hbty::Id::from(fd.file) {
+                            write!(
+                                self.asm.name,
+                                "{}",
+                                hbty::Display::new(types, files, fd.parent)
+                            )
+                            .unwrap();
+                        }
+                        self.asm.name.push_str(file.ident_str(fd.name));
+                        if fd.is_generic {
+                            let mut args = fd.sig.args.args();
+                            self.asm.name.push('(');
+                            while let Some(arg) = args.next(types) {
+                                if let hbty::Arg::Type(ty) = arg {
+                                    write!(
+                                        self.asm.name,
+                                        "{},",
+                                        hbty::Display::new(types, files, ty)
+                                    )
+                                    .unwrap();
+                                }
+                            }
+                            self.asm.name.pop().unwrap();
+                            self.asm.name.push(')');
+                        }
+                    }
+                    let linkage = if func == from {
+                        cm::Linkage::Export
+                    } else if fd.is_import {
+                        cm::Linkage::Import
+                    } else {
+                        cm::Linkage::Local
+                    };
+                    build_signature(
+                        module.isa().default_call_conv(),
+                        fd.sig,
+                        types,
+                        &mut self.ctx.func.signature,
+                        &mut vec![],
+                    );
+                    debug_assert!(seen_names.insert(self.asm.name.clone()), "{}", self.asm.name);
+                    fuc.module_id = Some(
+                        module
+                            .declare_function(&self.asm.name, linkage, &self.ctx.func.signature)
+                            .unwrap(),
+                    );
+                    if !fd.is_import {
+                        self.asm.funcs.push(func);
+                    }
+                }
+                hbty::Kind::Global(glob) => {
+                    if self.globals[glob].module_id.is_some() {
+                        continue;
+                    }
+                    self.asm.globals.push(glob);
+
+                    self.asm.name.clear();
+                    let mutable = if types.ins.globals[glob].file == Default::default() {
+                        writeln!(self.asm.name, "anon{}", glob.index()).unwrap();
+                        false
+                    } else {
+                        let file = &files[types.ins.globals[glob].file];
+                        self.asm.name.push_str(hblang::strip_cwd(&file.path));
+                        self.asm.name.push('.');
+                        self.asm.name.push_str(file.ident_str(types.ins.globals[glob].name));
+                        true
+                    };
+
+                    self.globals[glob].module_id = Some(
+                        module
+                            .declare_data(&self.asm.name, cm::Linkage::Local, mutable, false)
+                            .unwrap(),
+                    );
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        for &func in &self.asm.funcs {
+            let fuc = &self.funcs.headers[func];
+            assert!(!types.ins.funcs[func].is_import);
+            debug_assert!(!fuc.code.is_empty());
+            let names = &mut self.funcs.external_names
+                [fuc.external_names.start as usize..fuc.external_names.end as usize];
+            self.ctx.func.clear();
+            names.iter().for_each(|nm| {
+                let mut nm = nm.clone();
+                if nm.namespace == 0 {
+                    nm.index = self.funcs.headers[hbty::Func::new(nm.index as _)]
+                        .module_id
+                        .unwrap()
+                        .as_u32();
+                } else {
+                    nm.index =
+                        self.globals[hbty::Global::new(nm.index as _)].module_id.unwrap().as_u32();
+                }
+                let prev_len = self.ctx.func.params.user_named_funcs().len();
+                self.ctx.func.params.ensure_user_func_name(nm.clone());
+                debug_assert_ne!(self.ctx.func.params.user_named_funcs().len(), prev_len, "{}", nm);
+            });
+            module
+                .define_function_bytes(
+                    fuc.module_id.unwrap(),
+                    &self.ctx.func,
+                    fuc.alignment as _,
+                    &self.funcs.code[fuc.code.start as usize..fuc.code.end as usize],
+                    &self.funcs.relocs[fuc.relocs.start as usize..fuc.relocs.end as usize],
+                )
+                .unwrap();
+        }
+
+        for global in self.asm.globals.drain(..) {
+            let glob = &self.globals[global];
+            self.dt_ctx.clear();
+            self.dt_ctx.define(types.ins.globals[global].data.clone().into());
+            module.define_data(glob.module_id.unwrap(), &self.dt_ctx).unwrap();
+        }
+
+        module.finish().object.write_stream(to).unwrap();
+
+        hblang::backend::AssemblySpec { code_length: 0, data_length: 0, entry: 0 }
+    }
+
+    fn disasm<'a>(
+        &'a self,
+        _sluce: &[u8],
+        _eca_handler: &mut dyn FnMut(&mut &[u8]),
+        _types: &'a hbty::Types,
+        _files: &'a hbutils::EntSlice<hbty::Module, hblang::parser::Ast>,
+        _output: &mut String,
+    ) -> Result<(), std::boxed::Box<dyn core::error::Error + Send + Sync + 'a>> {
+        unimplemented!()
+    }
+
+    fn emit_body(
+        &mut self,
+        id: hbty::Func,
+        nodes: &hbnodes::Nodes,
+        tys: &hbty::Types,
+        files: &hbutils::EntSlice<hbty::Module, hblang::parser::Ast>,
+    ) {
+        let isa = self.module.as_ref().unwrap().isa();
+
+        let mut lens = vec![];
+        let stack_ret = build_signature(
+            isa.default_call_conv(),
+            tys.ins.funcs[id].sig,
+            tys,
+            &mut self.ctx.func.signature,
+            &mut lens,
+        );
+
+        FuncBuilder {
+            bl: FunctionBuilder::new(&mut self.ctx.func, &mut self.fb_ctx),
+            isa,
+            nodes,
+            tys,
+            files,
+            values: &mut vec![None; nodes.len()],
+            arg_lens: &lens,
+            stack_ret,
+        }
+        .build(tys.ins.funcs[id].sig);
+
+        self.ctx.func.name =
+            cir::UserFuncName::User(cir::UserExternalName { namespace: 0, index: id.index() as _ });
+
+        //std::eprintln!("{}", self.ctx.func.display());
+
+        self.ctx.compile(isa, &mut self.ctrl_plane).unwrap();
+        let code = self.ctx.compiled_code().unwrap();
+        self.funcs.push(id, &self.ctx.func, &code.buffer);
+        self.ctx.clear();
+    }
+}
+
+fn build_signature(
+    call_conv: cc::isa::CallConv,
+    sig: hbty::Sig,
+    types: &hbty::Types,
+    signature: &mut cir::Signature,
+    arg_meta: &mut Vec<AbiMeta>,
+) -> bool {
+    signature.clear(call_conv);
+    match call_conv {
+        cc::isa::CallConv::SystemV => {
+            x86_64::build_systemv_signature(sig, types, signature, arg_meta)
+        }
+        _ => todo!(),
+    }
+}
+
+#[derive(Clone, Copy)]
+struct AbiMeta {
+    trough_mem: bool,
+    arg_count: usize,
+}
+
+struct FuncBuilder<'a, 'b> {
+    bl: cf::FunctionBuilder<'b>,
+    isa: &'a dyn TargetIsa,
+    nodes: &'a hbnodes::Nodes,
+    tys: &'a hbty::Types,
+    files: &'a hbutils::EntSlice<hbty::Module, hblang::parser::Ast>,
+    values: &'b mut [Option<Result<cir::Value, cir::Block>>],
+    arg_lens: &'a [AbiMeta],
+    stack_ret: bool,
+}
+
+impl FuncBuilder<'_, '_> {
+    pub fn build(mut self, sig: hbty::Sig) {
+        let entry = self.bl.create_block();
+        self.bl.append_block_params_for_function_params(entry);
+        self.bl.switch_to_block(entry);
+        let mut arg_vals = &self.bl.block_params(entry).to_vec()[..];
+
+        if self.stack_ret {
+            let ret_ptr = *arg_vals.take_first().unwrap();
+            self.values[hbnodes::MEM as usize] = Some(Ok(ret_ptr));
+        }
+
+        let Self { nodes, tys, .. } = self;
+
+        let mut parama_len = self.arg_lens[1..].iter();
+        let mut typs = sig.args.args();
+        let mut args = nodes[hbnodes::VOID].outputs[hbnodes::ARG_START..].iter();
+        while let Some(aty) = typs.next(tys) {
+            let hbty::Arg::Value(ty) = aty else { continue };
+            let abi_meta = parama_len.next().unwrap();
+            let &arg = args.next().unwrap();
+            if !abi_meta.trough_mem && ty.is_aggregate(tys) {
+                let slot = self.bl.create_sized_stack_slot(cir::StackSlotData {
+                    kind: cir::StackSlotKind::ExplicitSlot,
+                    size: self.tys.size_of(ty),
+                    align_shift: self.tys.align_of(ty).ilog2() as _,
+                });
+                let loc = arg_vals.take(..abi_meta.arg_count).unwrap();
+                assert!(loc.len() <= 2, "NEED handling");
+                let align =
+                    loc.iter().map(|&p| self.bl.func.dfg.value_type(p).bytes()).max().unwrap();
+                let mut offset = 0i32;
+                for &v in loc {
+                    self.bl.ins().stack_store(v, slot, offset);
+                    offset += align as i32;
+                }
+                self.values[arg as usize] =
+                    Some(Ok(self.bl.ins().stack_addr(cir::types::I64, slot, 0)))
+            } else {
+                let loc = arg_vals.take(..abi_meta.arg_count).unwrap();
+                debug_assert_eq!(loc.len(), 1);
+                self.values[arg as usize] = Some(Ok(loc[0]));
+            }
+        }
+
+        self.values[hbnodes::ENTRY as usize] = Some(Err(entry));
+
+        self.emit_node(hbnodes::VOID, hbnodes::VOID);
+
+        self.bl.finalize();
+    }
+
+    fn value_of(&self, nid: hbnodes::Nid) -> cir::Value {
+        self.values[nid as usize].unwrap_or_else(|| panic!("{:?}", self.nodes[nid])).unwrap()
+    }
+
+    fn block_of(&self, nid: hbnodes::Nid) -> cir::Block {
+        self.values[nid as usize].unwrap().unwrap_err()
+    }
+
+    fn close_block(&mut self, nid: hbnodes::Nid) {
+        if matches!(self.nodes[nid].kind, hbnodes::Kind::Loop) {
+            return;
+        }
+        self.bl.seal_block(self.block_of(nid));
+    }
+
+    fn emit_node(&mut self, nid: hbnodes::Nid, block: hbnodes::Nid) {
+        use hbnodes::*;
+
+        let mut args = vec![];
+        if matches!(self.nodes[nid].kind, Kind::Region | Kind::Loop) {
+            let side = 1 + self.values[nid as usize].is_some() as usize;
+            for &o in self.nodes[nid].outputs.iter() {
+                if self.nodes[o].is_data_phi() {
+                    args.push(self.value_of(self.nodes[o].inputs[side]));
+                }
+            }
+            match (self.nodes[nid].kind, self.values[nid as usize]) {
+                (Kind::Loop, Some(blck)) => {
+                    self.bl.ins().jump(blck.unwrap_err(), &args);
+                    self.bl.seal_block(blck.unwrap_err());
+                    self.close_block(block);
+                    return;
+                }
+                (Kind::Region, None) => {
+                    let next = self.bl.create_block();
+                    for &o in self.nodes[nid].outputs.iter() {
+                        if self.nodes[o].is_data_phi() {
+                            self.values[o as usize] = Some(Ok(self
+                                .bl
+                                .append_block_param(next, self.nodes[o].ty.to_clif(self.tys))));
+                        }
+                    }
+                    self.bl.ins().jump(next, &args);
+                    self.close_block(block);
+                    self.values[nid as usize] = Some(Err(next));
+                    return;
+                }
+                _ => {}
+            }
+        }
+
+        let node = &self.nodes[nid];
+        self.values[nid as usize] = Some(match node.kind {
+            Kind::Start => {
+                debug_assert_eq!(self.nodes[node.outputs[0]].kind, Kind::Entry);
+                self.emit_node(node.outputs[0], block);
+                return;
+            }
+            Kind::If => {
+                let &[_, cnd] = node.inputs.as_slice() else { unreachable!() };
+                let &[then, else_] = node.outputs.as_slice() else { unreachable!() };
+
+                let then_bl = self.bl.create_block();
+                let else_bl = self.bl.create_block();
+                let c = self.value_of(cnd);
+                self.bl.ins().brif(c, then_bl, &[], else_bl, &[]);
+                self.values[then as usize] = Some(Err(then_bl));
+                self.values[else_ as usize] = Some(Err(else_bl));
+
+                self.close_block(block);
+                self.bl.switch_to_block(then_bl);
+                self.emit_node(then, then);
+                self.bl.switch_to_block(else_bl);
+                self.emit_node(else_, else_);
+                Err(self.block_of(block))
+            }
+            Kind::Loop => {
+                let next = self.bl.create_block();
+                for &o in self.nodes[nid].outputs.iter() {
+                    if self.nodes[o].is_data_phi() {
+                        self.values[o as usize] = Some(Ok(self
+                            .bl
+                            .append_block_param(next, self.nodes[o].ty.to_clif(self.tys))));
+                    }
+                }
+                self.values[nid as usize] = Some(Err(next));
+                self.bl.ins().jump(self.values[nid as usize].unwrap().unwrap_err(), &args);
+                self.close_block(block);
+                self.bl.switch_to_block(self.values[nid as usize].unwrap().unwrap_err());
+                for &o in node.outputs.iter().rev() {
+                    self.emit_node(o, nid);
+                }
+                Err(self.block_of(block))
+            }
+            Kind::Region => {
+                self.bl.ins().jump(self.values[nid as usize].unwrap().unwrap_err(), &args);
+                self.close_block(block);
+                self.bl.switch_to_block(self.values[nid as usize].unwrap().unwrap_err());
+                for &o in node.outputs.iter().rev() {
+                    self.emit_node(o, nid);
+                }
+                return;
+            }
+            Kind::Die => {
+                self.bl.ins().trap(TrapCode::unwrap_user(1));
+                self.close_block(block);
+                self.emit_node(node.outputs[0], block);
+                Err(self.block_of(block))
+            }
+            Kind::Return { .. } => {
+                let mut ir_args = vec![];
+                if node.inputs[1] == hbnodes::VOID {
+                } else {
+                    let abi_meta = self.arg_lens[0];
+                    let arg = node.inputs[1];
+                    if !abi_meta.trough_mem && self.nodes[node.inputs[1]].ty.is_aggregate(self.tys)
+                    {
+                        let loc = self.bl.func.signature.returns.clone();
+                        assert!(loc.len() <= 2, "NEED handling");
+                        let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap();
+                        let mut offset = 0i32;
+                        let src = self.value_of(self.nodes[arg].inputs[1]);
+                        debug_assert!(self.nodes[arg].kind == Kind::Load);
+                        for &v in &loc {
+                            ir_args.push(self.bl.ins().load(
+                                v.value_type,
+                                MemFlags::new(),
+                                src,
+                                offset,
+                            ));
+                            offset += align as i32;
+                        }
+                    } else if self.stack_ret {
+                        let src = self.value_of(self.nodes[arg].inputs[1]);
+                        let dest = self.value_of(MEM);
+                        self.bl.emit_small_memory_copy(
+                            self.isa.frontend_config(),
+                            dest,
+                            src,
+                            self.tys.size_of(self.nodes[arg].ty) as _,
+                            self.tys.align_of(self.nodes[arg].ty) as _,
+                            self.tys.align_of(self.nodes[arg].ty) as _,
+                            false,
+                            MemFlags::new(),
+                        );
+                    } else {
+                        ir_args.push(self.value_of(arg));
+                    }
+                }
+
+                self.bl.ins().return_(&ir_args);
+                self.close_block(block);
+                self.emit_node(node.outputs[0], block);
+                Err(self.block_of(block))
+            }
+            Kind::Entry => {
+                for &o in node.outputs.iter().rev() {
+                    self.emit_node(o, nid);
+                }
+                return;
+            }
+            Kind::Then | Kind::Else => {
+                for &o in node.outputs.iter().rev() {
+                    self.emit_node(o, block);
+                }
+                Err(self.block_of(block))
+            }
+            Kind::Call { func, unreachable, args } => {
+                assert_ne!(func, hbty::Func::ECA, "@eca is not supported");
+
+                if unreachable {
+                    todo!()
+                } else {
+                    let mut arg_lens = vec![];
+                    let mut signature = cir::Signature::new(self.isa.default_call_conv());
+                    let stack_ret = build_signature(
+                        self.isa.default_call_conv(),
+                        self.tys.ins.funcs[func].sig,
+                        self.tys,
+                        &mut signature,
+                        &mut arg_lens,
+                    );
+
+                    let func_ref =
+                        'b: {
+                            let user_name_ref = self.bl.func.declare_imported_user_function(
+                                cir::UserExternalName { namespace: 0, index: func.index() as _ },
+                            );
+
+                            if let Some(id) = self.bl.func.dfg.ext_funcs.keys().find(|&k| {
+                                self.bl.func.dfg.ext_funcs[k].name
+                                    == cir::ExternalName::user(user_name_ref)
+                            }) {
+                                break 'b id;
+                            }
+
+                            let signature = self.bl.func.import_signature(signature.clone());
+
+                            self.bl.func.import_function(cir::ExtFuncData {
+                                name: cir::ExternalName::user(user_name_ref),
+                                signature,
+                                // somehow, this works
+                                colocated: true, // !self.tys.ins.funcs[func].is_import,
+                            })
+                        };
+
+                    let mut ir_args = vec![];
+
+                    if stack_ret {
+                        ir_args.push(self.value_of(*node.inputs.last().unwrap()));
+                    }
+
+                    let mut params = signature.params.as_slice();
+                    let mut parama_len = arg_lens[1..].iter();
+                    let mut typs = args.args();
+                    let mut args = node.inputs[1..].iter();
+                    while let Some(aty) = typs.next(self.tys) {
+                        let hbty::Arg::Value(ty) = aty else { continue };
+                        let abi_meta = parama_len.next().unwrap();
+                        if abi_meta.arg_count == 0 {
+                            continue;
+                        }
+                        let &arg = args.next().unwrap();
+                        if !abi_meta.trough_mem && ty.is_aggregate(self.tys) {
+                            let loc = params.take(..abi_meta.arg_count).unwrap();
+                            assert!(loc.len() <= 2, "NEED handling");
+                            let align = loc.iter().map(|&p| p.value_type.bytes()).max().unwrap();
+                            let mut offset = 0i32;
+                            let src = self.value_of(self.nodes[arg].inputs[1]);
+                            debug_assert!(self.nodes[arg].kind == Kind::Load);
+                            for &v in loc {
+                                ir_args.push(self.bl.ins().load(
+                                    v.value_type,
+                                    MemFlags::new(),
+                                    src,
+                                    offset,
+                                ));
+                                offset += align as i32;
+                            }
+                        } else {
+                            let loc = params.take(..abi_meta.arg_count).unwrap();
+                            debug_assert_eq!(loc.len(), 1);
+                            ir_args.push(self.value_of(arg));
+                        }
+                    }
+
+                    let inst = self.bl.ins().call(func_ref, &ir_args);
+                    match *self.bl.inst_results(inst) {
+                        [] => {}
+                        [scala] => self.values[nid as usize] = Some(Ok(scala)),
+                        [a, b] => {
+                            assert!(!stack_ret);
+                            let slot = self.value_of(*node.inputs.last().unwrap());
+
+                            let loc = [a, b];
+                            assert!(loc.len() <= 2, "NEED handling");
+                            let align = loc
+                                .iter()
+                                .map(|&p| self.bl.func.dfg.value_type(p).bytes())
+                                .max()
+                                .unwrap();
+                            let mut offset = 0i32;
+                            for v in loc {
+                                self.bl.ins().store(MemFlags::new(), v, slot, offset);
+                                offset += align as i32;
+                            }
+                        }
+                        _ => unimplemented!(),
+                    }
+                    for &o in node.outputs.iter().rev() {
+                        if self.nodes[o].inputs[0] == nid
+                            || (matches!(self.nodes[o].kind, Kind::Loop | Kind::Region)
+                                && self.nodes[o].inputs[1] == nid)
+                        {
+                            self.emit_node(o, block);
+                        }
+                    }
+                    return;
+                }
+            }
+            Kind::CInt { value } if self.nodes[nid].ty.is_float() => {
+                Ok(match self.tys.size_of(self.nodes[nid].ty) {
+                    4 => self.bl.ins().f32const(f64::from_bits(value as _) as f32),
+                    8 => self.bl.ins().f64const(f64::from_bits(value as _)),
+                    _ => unimplemented!(),
+                })
+            }
+            Kind::CInt { value } => Ok(self.bl.ins().iconst(
+                cir::Type::int(self.tys.size_of(node.ty) as u16 * 8).unwrap_or_else(|| {
+                    panic!("{}", hbty::Display::new(self.tys, self.files, node.ty),)
+                }),
+                value,
+            )),
+            Kind::BinOp { op } => {
+                let &[_, lhs, rhs] = node.inputs.as_slice() else { unreachable!() };
+                let [lh, rh] = [self.value_of(lhs), self.value_of(rhs)];
+
+                let is_int_op = node.ty.is_integer()
+                    || node.ty.is_pointer()
+                    || (node.ty == hbty::Id::BOOL
+                        && (self.nodes[lhs].ty.is_integer()
+                            || node.ty.is_pointer()
+                            || self.nodes[lhs].ty == hbty::Id::BOOL));
+                let is_float_op = node.ty.is_float()
+                    || (node.ty == hbty::Id::BOOL && self.nodes[lhs].ty.is_float());
+
+                Ok(if is_int_op {
+                    let signed = node.ty.is_signed();
+                    match op {
+                        TokenKind::Add => self.bl.ins().iadd(lh, rh),
+                        TokenKind::Sub => self.bl.ins().isub(lh, rh),
+                        TokenKind::Mul => self.bl.ins().imul(lh, rh),
+                        TokenKind::Shl => self.bl.ins().ishl(lh, rh),
+                        TokenKind::Xor => self.bl.ins().bxor(lh, rh),
+                        TokenKind::Band => self.bl.ins().band(lh, rh),
+                        TokenKind::Bor => self.bl.ins().bor(lh, rh),
+
+                        TokenKind::Div if signed => self.bl.ins().sdiv(lh, rh),
+                        TokenKind::Mod if signed => self.bl.ins().srem(lh, rh),
+                        TokenKind::Shr if signed => self.bl.ins().sshr(lh, rh),
+
+                        TokenKind::Div => self.bl.ins().udiv(lh, rh),
+                        TokenKind::Mod => self.bl.ins().urem(lh, rh),
+                        TokenKind::Shr => self.bl.ins().ushr(lh, rh),
+
+                        TokenKind::Lt
+                        | TokenKind::Gt
+                        | TokenKind::Le
+                        | TokenKind::Ge
+                        | TokenKind::Eq
+                        | TokenKind::Ne => self.bl.ins().icmp(op.to_int_cc(signed), lh, rh),
+                        op => todo!("{op}"),
+                    }
+                } else if is_float_op {
+                    match op {
+                        TokenKind::Add => self.bl.ins().fadd(lh, rh),
+                        TokenKind::Sub => self.bl.ins().fsub(lh, rh),
+                        TokenKind::Mul => self.bl.ins().fmul(lh, rh),
+                        TokenKind::Div => self.bl.ins().fdiv(lh, rh),
+
+                        TokenKind::Lt
+                        | TokenKind::Gt
+                        | TokenKind::Le
+                        | TokenKind::Ge
+                        | TokenKind::Eq
+                        | TokenKind::Ne => self.bl.ins().fcmp(op.to_float_cc(), lh, rh),
+                        op => todo!("{op}"),
+                    }
+                } else {
+                    todo!("{}", hbty::Display::new(self.tys, self.files, node.ty))
+                })
+            }
+            Kind::RetVal => Ok(self.value_of(node.inputs[0])),
+            Kind::UnOp { op } => {
+                let oper = self.value_of(node.inputs[1]);
+                let dst = node.ty;
+                let src = self
+                    .tys
+                    .inner_of(self.nodes[node.inputs[1]].ty)
+                    .unwrap_or(self.nodes[node.inputs[1]].ty);
+
+                let dty = dst.to_clif(self.tys);
+                Ok(match op {
+                    TokenKind::Sub => self.bl.ins().ineg(oper),
+                    TokenKind::Not => self.bl.ins().bnot(oper),
+                    TokenKind::Float if dst.is_float() && src.is_unsigned() => {
+                        self.bl.ins().fcvt_from_uint(dty, oper)
+                    }
+                    TokenKind::Float if dst.is_float() && src.is_signed() => {
+                        self.bl.ins().fcvt_from_sint(dty, oper)
+                    }
+                    TokenKind::Number if src.is_float() && dst.is_unsigned() => {
+                        self.bl.ins().fcvt_to_uint(dty, oper)
+                    }
+                    TokenKind::Number
+                        if src.is_signed() && (dst.is_integer() || dst.is_pointer()) =>
+                    {
+                        self.bl.ins().sextend(dty, oper)
+                    }
+                    TokenKind::Number
+                        if (src.is_unsigned() || src == hbty::Id::BOOL)
+                            && (dst.is_integer() || dst.is_pointer()) =>
+                    {
+                        self.bl.ins().uextend(dty, oper)
+                    }
+                    TokenKind::Float if dst == hbty::Id::F64 && src.is_float() => {
+                        self.bl.ins().fpromote(dty, oper)
+                    }
+                    TokenKind::Float if dst == hbty::Id::F32 && src.is_float() => {
+                        self.bl.ins().fdemote(dty, oper)
+                    }
+                    _ => todo!(),
+                })
+            }
+            Kind::Stck => {
+                let slot = self.bl.create_sized_stack_slot(cir::StackSlotData {
+                    kind: cir::StackSlotKind::ExplicitSlot,
+                    size: self.tys.size_of(node.ty),
+                    align_shift: self.tys.align_of(node.ty).ilog2() as _,
+                });
+
+                Ok(self.bl.ins().stack_addr(cir::types::I64, slot, 0))
+            }
+            Kind::Global { global } => {
+                let glob_ref = {
+                    // already deduplicated by the SoN
+                    let colocated = true;
+                    let user_name_ref =
+                        self.bl.func.declare_imported_user_function(cir::UserExternalName {
+                            namespace: 1,
+                            index: global.index() as u32,
+                        });
+                    self.bl.func.create_global_value(cir::GlobalValueData::Symbol {
+                        name: cir::ExternalName::user(user_name_ref),
+                        offset: cir::immediates::Imm64::new(0),
+                        colocated,
+                        tls: false,
+                    })
+                };
+
+                Ok(self.bl.ins().global_value(cir::types::I64, glob_ref))
+            }
+            Kind::Load if node.ty.is_aggregate(self.tys) => return,
+            Kind::Load => {
+                let ptr = self.value_of(node.inputs[1]);
+                Ok(self.bl.ins().load(node.ty.to_clif(self.tys), MemFlags::new(), ptr, 0))
+            }
+            Kind::Stre if node.ty.is_aggregate(self.tys) => {
+                let src = self.value_of(self.nodes[node.inputs[1]].inputs[1]);
+                let dest = self.value_of(node.inputs[2]);
+                self.bl.emit_small_memory_copy(
+                    self.isa.frontend_config(),
+                    dest,
+                    src,
+                    self.tys.size_of(node.ty) as _,
+                    self.tys.align_of(node.ty) as _,
+                    self.tys.align_of(node.ty) as _,
+                    false,
+                    MemFlags::new(),
+                );
+                return;
+            }
+            Kind::Stre => {
+                let value = self.value_of(node.inputs[1]);
+                let ptr = self.value_of(node.inputs[2]);
+                self.bl.ins().store(MemFlags::new(), value, ptr, 0);
+                return;
+            }
+            Kind::End | Kind::Phi | Kind::Arg | Kind::Mem | Kind::Loops | Kind::Join => return,
+            Kind::Assert { .. } => unreachable!(),
+        });
+    }
+}
+
+trait ToCondcodes {
+    fn to_int_cc(self, signed: bool) -> condcodes::IntCC;
+    fn to_float_cc(self) -> condcodes::FloatCC;
+}
+
+impl ToCondcodes for TokenKind {
+    fn to_int_cc(self, signed: bool) -> condcodes::IntCC {
+        use condcodes::IntCC as ICC;
+        match self {
+            Self::Lt if signed => ICC::SignedLessThan,
+            Self::Gt if signed => ICC::SignedGreaterThan,
+            Self::Le if signed => ICC::SignedLessThanOrEqual,
+            Self::Ge if signed => ICC::SignedGreaterThanOrEqual,
+
+            Self::Lt => ICC::UnsignedLessThan,
+            Self::Gt => ICC::UnsignedGreaterThan,
+            Self::Le => ICC::UnsignedLessThanOrEqual,
+            Self::Ge => ICC::UnsignedGreaterThanOrEqual,
+
+            Self::Eq => ICC::Equal,
+            Self::Ne => ICC::NotEqual,
+            _ => unreachable!(),
+        }
+    }
+
+    fn to_float_cc(self) -> condcodes::FloatCC {
+        use condcodes::FloatCC as FCC;
+        match self {
+            Self::Lt => FCC::LessThan,
+            Self::Gt => FCC::GreaterThan,
+            Self::Le => FCC::LessThanOrEqual,
+            Self::Ge => FCC::GreaterThanOrEqual,
+            Self::Eq => FCC::Equal,
+            Self::Ne => FCC::NotEqual,
+            _ => unreachable!(),
+        }
+    }
+}
+
+trait ToClifTy {
+    fn to_clif(self, cx: &hbty::Types) -> cir::Type;
+}
+
+impl ToClifTy for hbty::Id {
+    fn to_clif(self, cx: &hbty::Types) -> cir::Type {
+        debug_assert!(!self.is_aggregate(cx));
+        if self.is_integer() | self.is_pointer() | self.is_optional() || self == hbty::Id::BOOL {
+            cir::Type::int(cx.size_of(self) as u16 * 8).unwrap()
+        } else if self == hbty::Id::F32 {
+            cir::types::F32
+        } else if self == hbty::Id::F64 {
+            cir::types::F64
+        } else {
+            unimplemented!("{:?}", self)
+        }
+    }
+}
+
+#[derive(Default)]
+struct Global {
+    module_id: Option<cm::DataId>,
+}
+
+#[derive(Default)]
+struct FuncHeaders {
+    module_id: Option<cm::FuncId>,
+    alignment: u32,
+    code: Range<u32>,
+    relocs: Range<u32>,
+    external_names: Range<u32>,
+}
+
+#[derive(Default)]
+struct Functions {
+    headers: EntVec<hbty::Func, FuncHeaders>,
+    code: Vec<u8>,
+    relocs: Vec<FinalizedMachReloc>,
+    external_names: Vec<UserExternalName>,
+}
+
+impl Functions {
+    fn push(&mut self, id: hbty::Func, func: &cir::Function, code: &MachBufferFinalized<Final>) {
+        self.headers.shadow(id.index() + 1);
+        self.headers[id] = FuncHeaders {
+            module_id: None,
+            alignment: code.alignment,
+            code: self.code.len() as u32..self.code.len() as u32 + code.data().len() as u32,
+            relocs: self.relocs.len() as u32..self.relocs.len() as u32 + code.relocs().len() as u32,
+            external_names: self.external_names.len() as u32
+                ..self.external_names.len() as u32 + func.params.user_named_funcs().len() as u32,
+        };
+        self.code.extend(code.data());
+        self.relocs.extend(code.relocs().iter().cloned());
+        self.external_names.extend(func.params.user_named_funcs().values().cloned());
+    }
+}
+
+#[derive(Default)]
+struct Assembler {
+    name: String,
+    frontier: Vec<hbty::Id>,
+    globals: Vec<hbty::Global>,
+    funcs: Vec<hbty::Func>,
+}
+
+#[derive(Debug)]
+pub enum BackendCreationError {
+    UnsupportedTriplet(LookupError),
+    InvalidFlags(CodegenError),
+    UnsupportedModuleConfig(ModuleError),
+    InvalidFlag { key: String, value: String, err: SetError },
+}
+
+impl Display for BackendCreationError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            BackendCreationError::UnsupportedTriplet(err) => {
+                write!(f, "Unsupported triplet: {}", err)
+            }
+            BackendCreationError::InvalidFlags(err) => {
+                write!(f, "Invalid flags: {}", err)
+            }
+            BackendCreationError::UnsupportedModuleConfig(err) => {
+                write!(f, "Unsupported module configuration: {}", err)
+            }
+            BackendCreationError::InvalidFlag { key, value, err } => {
+                write!(
+                    f,
+                    "Problem setting a '{key}' to '{value}': {err}\navailable flags: {}",
+                    cc::settings::Flags::new(cc::settings::builder())
+                )
+            }
+        }
+    }
+}
+impl core::error::Error for BackendCreationError {}
+
+impl From<LookupError> for BackendCreationError {
+    fn from(value: LookupError) -> Self {
+        Self::UnsupportedTriplet(value)
+    }
+}
+
+impl From<CodegenError> for BackendCreationError {
+    fn from(value: CodegenError) -> Self {
+        Self::InvalidFlags(value)
+    }
+}
+
+impl From<ModuleError> for BackendCreationError {
+    fn from(value: ModuleError) -> Self {
+        Self::UnsupportedModuleConfig(value)
+    }
+}

cranelift-backend/src/x86_64.rs

@@ -0,0 +1,310 @@
+// The classification code for the x86_64 ABI is taken from the clay language
+// https://github.com/jckarter/clay/blob/db0bd2702ab0b6e48965cd85f8859bbd5f60e48e/compiler/externals.cpp
+
+use {crate::AbiMeta, hblang::ty};
+
+pub fn build_systemv_signature(
+    sig: hblang::ty::Sig,
+    types: &hblang::ty::Types,
+    signature: &mut cranelift_codegen::ir::Signature,
+    arg_lens: &mut Vec<AbiMeta>,
+) -> bool {
+    let mut alloca = Alloca::new();
+
+    alloca.next(false, sig.ret, types, &mut signature.returns);
+    let stack_ret = signature.returns.len() == 1
+        && signature.returns[0].purpose == cranelift_codegen::ir::ArgumentPurpose::StructReturn;
+
+    if stack_ret {
+        signature.params.append(&mut signature.returns);
+        arg_lens.push(AbiMeta { arg_count: signature.params.len(), trough_mem: true });
+    } else {
+        arg_lens.push(AbiMeta { arg_count: signature.returns.len(), trough_mem: false });
+    }
+
+    let mut args = sig.args.args();
+    while let Some(arg) = args.next_value(types) {
+        let prev = signature.params.len();
+        let trough_mem = alloca.next(true, arg, types, &mut signature.params);
+        arg_lens.push(AbiMeta { arg_count: signature.params.len() - prev, trough_mem });
+    }
+
+    stack_ret
+}
+
+/// Classification of "eightbyte" components.
+// N.B., the order of the variants is from general to specific,
+// such that `unify(a, b)` is the "smaller" of `a` and `b`.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+enum Class {
+    Int,
+    Sse,
+    SseUp,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Memory;
+
+// Currently supported vector size (AVX-512).
+const LARGEST_VECTOR_SIZE: usize = 512;
+const MAX_EIGHTBYTES: usize = LARGEST_VECTOR_SIZE / 64;
+
+fn classify_arg(
+    cx: &hblang::ty::Types,
+    arg: hblang::ty::Id,
+) -> Result<[Option<Class>; MAX_EIGHTBYTES], Memory> {
+    fn classify(
+        cx: &hblang::ty::Types,
+        layout: hblang::ty::Id,
+        cls: &mut [Option<Class>],
+        off: hblang::ty::Offset,
+    ) -> Result<(), Memory> {
+        let size = cx.size_of(layout);
+        if off & (cx.align_of(layout) - 1) != 0 {
+            if size != 0 {
+                return Err(Memory);
+            }
+            return Ok(());
+        }
+
+        let mut c = match layout.expand() {
+            _ if size == 0 => return Ok(()),
+            _ if layout.is_integer() || layout.is_pointer() || layout == ty::Id::BOOL => Class::Int,
+            _ if layout.is_float() => Class::Sse,
+
+            hblang::ty::Kind::Struct(s) => {
+                for (f, foff) in hblang::ty::OffsetIter::new(s, cx).into_iter(cx) {
+                    classify(cx, f.ty, cls, off + foff)?;
+                }
+                return Ok(());
+            }
+            hblang::ty::Kind::Tuple(tuple) => {
+                for (&ty, foff) in hblang::ty::OffsetIter::new(tuple, cx).into_iter(cx) {
+                    classify(cx, ty, cls, off + foff)?;
+                }
+                return Ok(());
+            }
+            hblang::ty::Kind::Enum(_) => Class::Int,
+            hblang::ty::Kind::Union(union) => {
+                for f in cx.union_fields(union) {
+                    classify(cx, f.ty, cls, off)?;
+                }
+                return Ok(());
+            }
+            hblang::ty::Kind::Slice(slice) if let Some(len) = cx.ins.slices[slice].len() => {
+                for i in 0..len as u32 {
+                    classify(
+                        cx,
+                        cx.ins.slices[slice].elem,
+                        cls,
+                        off + i * cx.size_of(cx.ins.slices[slice].elem),
+                    )?;
+                }
+                return Ok(());
+            }
+            hblang::ty::Kind::Slice(_) => {
+                classify(cx, hblang::ty::Id::UINT, cls, off)?;
+                classify(cx, hblang::ty::Id::UINT, cls, off + 8)?;
+                return Ok(());
+            }
+            hblang::ty::Kind::Opt(opt) => {
+                let base = cx.ins.opts[opt].base;
+                if cx.nieche_of(base).is_some() {
+                    classify(cx, base, cls, off)?;
+                } else {
+                    classify(cx, hblang::ty::Id::BOOL, cls, off)?;
+                    classify(cx, base, cls, off + cx.align_of(base))?;
+                }
+                return Ok(());
+            }
+
+            ty => unimplemented!("{ty:?}"),
+        };
+
+        // Fill in `cls` for scalars (Int/Sse) and vectors (Sse).
+        let first = (off / 8) as usize;
+        let last = ((off + size - 1) / 8) as usize;
+        for cls in &mut cls[first..=last] {
+            *cls = Some(cls.map_or(c, |old| old.min(c)));
+
+            // Everything after the first Sse "eightbyte"
+            // component is the upper half of a register.
+            if c == Class::Sse {
+                c = Class::SseUp;
+            }
+        }
+
+        Ok(())
+    }
+
+    let size = cx.size_of(arg);
+    let n = ((size + 7) / 8) as usize;
+    if n > MAX_EIGHTBYTES {
+        return Err(Memory);
+    }
+
+    let mut cls = [None; MAX_EIGHTBYTES];
+    classify(cx, arg, &mut cls, 0)?;
+    if n > 2 {
+        if cls[0] != Some(Class::Sse) {
+            return Err(Memory);
+        }
+        if cls[1..n].iter().any(|&c| c != Some(Class::SseUp)) {
+            return Err(Memory);
+        }
+    } else {
+        let mut i = 0;
+        while i < n {
+            if cls[i] == Some(Class::SseUp) {
+                cls[i] = Some(Class::Sse);
+            } else if cls[i] == Some(Class::Sse) {
+                i += 1;
+                while i != n && cls[i] == Some(Class::SseUp) {
+                    i += 1;
+                }
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    Ok(cls)
+}
+
+fn reg_component(
+    cls: &[Option<Class>],
+    i: &mut usize,
+    size: hblang::ty::Size,
+) -> Option<cranelift_codegen::ir::Type> {
+    if *i >= cls.len() {
+        return None;
+    }
+
+    match cls[*i] {
+        None => None,
+        Some(Class::Int) => {
+            *i += 1;
+            Some(if size < 8 {
+                cranelift_codegen::ir::Type::int(size as u16 * 8).unwrap()
+            } else {
+                cranelift_codegen::ir::types::I64
+            })
+        }
+        Some(Class::Sse) => {
+            let vec_len =
+                1 + cls[*i + 1..].iter().take_while(|&&c| c == Some(Class::SseUp)).count();
+            *i += vec_len;
+            Some(if vec_len == 1 {
+                match size {
+                    4 => cranelift_codegen::ir::types::F32,
+                    _ => cranelift_codegen::ir::types::F64,
+                }
+            } else {
+                cranelift_codegen::ir::types::I64.by(vec_len as _).unwrap()
+            })
+        }
+        Some(c) => unreachable!("reg_component: unhandled class {:?}", c),
+    }
+}
+
+fn cast_target(
+    cls: &[Option<Class>],
+    size: hblang::ty::Size,
+    dest: &mut Vec<cranelift_codegen::ir::AbiParam>,
+) {
+    let mut i = 0;
+    let lo = reg_component(cls, &mut i, size).unwrap();
+    let offset = 8 * (i as u32);
+    dest.push(cranelift_codegen::ir::AbiParam::new(lo));
+    if size > offset {
+        if let Some(hi) = reg_component(cls, &mut i, size - offset) {
+            dest.push(cranelift_codegen::ir::AbiParam::new(hi));
+        }
+    }
+    assert_eq!(reg_component(cls, &mut i, 0), None);
+}
+
+const MAX_INT_REGS: usize = 6; // RDI, RSI, RDX, RCX, R8, R9
+const MAX_SSE_REGS: usize = 8; // XMM0-7
+
+pub struct Alloca {
+    int_regs: usize,
+    sse_regs: usize,
+}
+
+impl Alloca {
+    pub fn new() -> Self {
+        Self { int_regs: MAX_INT_REGS, sse_regs: MAX_SSE_REGS }
+    }
+
+    pub fn next(
+        &mut self,
+        is_arg: bool,
+        arg: hblang::ty::Id,
+        cx: &hblang::ty::Types,
+        dest: &mut Vec<cranelift_codegen::ir::AbiParam>,
+    ) -> bool {
+        if cx.size_of(arg) == 0 {
+            return false;
+        }
+
+        let mut cls_or_mem = classify_arg(cx, arg);
+
+        if is_arg {
+            if let Ok(cls) = cls_or_mem {
+                let mut needed_int = 0;
+                let mut needed_sse = 0;
+                for c in cls {
+                    match c {
+                        Some(Class::Int) => needed_int += 1,
+                        Some(Class::Sse) => needed_sse += 1,
+                        _ => {}
+                    }
+                }
+                match (self.int_regs.checked_sub(needed_int), self.sse_regs.checked_sub(needed_sse))
+                {
+                    (Some(left_int), Some(left_sse)) => {
+                        self.int_regs = left_int;
+                        self.sse_regs = left_sse;
+                    }
+                    _ => {
+                        // Not enough registers for this argument, so it will be
+                        // passed on the stack, but we only mark aggregates
+                        // explicitly as indirect `byval` arguments, as LLVM will
+                        // automatically put immediates on the stack itself.
+                        if arg.is_aggregate(cx) {
+                            cls_or_mem = Err(Memory);
+                        }
+                    }
+                }
+            }
+        }
+
+        match cls_or_mem {
+            Err(Memory) => {
+                if is_arg {
+                    dest.push(cranelift_codegen::ir::AbiParam::new(
+                        cranelift_codegen::ir::types::I64,
+                    ));
+                } else {
+                    dest.push(cranelift_codegen::ir::AbiParam::special(
+                        cranelift_codegen::ir::types::I64,
+                        cranelift_codegen::ir::ArgumentPurpose::StructReturn,
+                    ));
+                }
+                true
+            }
+            Ok(ref cls) => {
+                // split into sized chunks passed individually
+                if arg.is_aggregate(cx) {
+                    cast_target(cls, cx.size_of(arg), dest);
+                } else {
+                    dest.push(cranelift_codegen::ir::AbiParam::new(
+                        reg_component(cls, &mut 0, cx.size_of(arg)).unwrap(),
+                    ));
+                }
+                false
+            }
+        }
+    }
+}

depell/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "depell"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+argon2 = "0.5.3"
+axum = "0.7.7"
+axum-server = { version = "0.7.1", optional = true, features = ["rustls", "tls-rustls"] }
+const_format = "0.2.33"
+getrandom = "0.2.15"
+hblang.workspace = true
+htmlm = "0.5.0"
+log = "0.4.22"
+rand_core = { version = "0.6.4", features = ["getrandom"] }
+rusqlite = { version = "0.32.1", features = ["bundled"] }
+serde = { version = "1.0.210", features = ["derive"] }
+time = "0.3.36"
+tokio = { version = "1.40.0", features = ["rt"] }
+
+[features]
+#default = ["tls"]
+tls = ["dep:axum-server"]

depell/README.md

@@ -0,0 +1,14 @@
+# Depell
+
+Depell is a website that allows users to import/post/run hblang code and create huge dependency graphs. Its currently hosted at https://depell.mlokis.tech.
+
+## Local Development
+
+Prerequirements:
+- rust nigthly toolchain: install rust from [here](https://www.rust-lang.org/tools/install)
+
+```bash
+rustup default nightly
+cargo xtask watch-depell-debug
+# browser http://localhost:8080
+```

depell/src/icons/download.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e8eaed"><path d="M480-320 280-520l56-58 104 104v-326h80v326l104-104 56 58-200 200ZM240-160q-33 0-56.5-23.5T160-240v-120h80v120h480v-120h80v120q0 33-23.5 56.5T720-160H240Z"/></svg>

depell/src/icons/run.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e8eaed"><path d="M320-200v-560l440 280-440 280Zm80-280Zm0 134 210-134-210-134v268Z"/></svg>

depell/src/index.css

@@ -0,0 +1,213 @@
+* {
+	font-family: var(--font);
+	line-height: 1.3;
+}
+
+body {
+	--primary: light-dark(white, #181A1B);
+	--secondary: light-dark(#EFEFEF, #212425);
+	--timestamp: light-dark(#555555, #AAAAAA);
+	--error: #ff3333;
+}
+
+body {
+	--small-gap: 5px;
+	--font: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+	--monospace: 'Courier New', Courier, monospace;
+
+	nav {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+
+		section:last-child {
+			display: flex;
+			gap: var(--small-gap);
+		}
+	}
+
+	main {
+		margin-top: var(--small-gap);
+		display: flex;
+		flex-direction: column;
+		gap: var(--small-gap);
+	}
+}
+
+div.preview {
+	margin: var(--small-gap) 0px;
+	display: flex;
+	flex-direction: column;
+	gap: var(--small-gap);
+
+	div.info {
+		display: flex;
+		gap: var(--small-gap);
+
+		span[apply=timestamp] {
+			color: var(--timestamp);
+		}
+	}
+
+	div.stat {
+		display: flex;
+
+		svg {
+			height: 18px;
+		}
+	}
+
+	div.code {
+		position: relative;
+
+		nav {
+			position: absolute;
+			right: 0;
+			padding: var(--small-gap);
+
+			button {
+				display: flex;
+				padding: 0;
+			}
+		}
+	}
+}
+
+svg {
+	fill: black;
+}
+
+form {
+	display: flex;
+	flex-direction: column;
+	gap: var(--small-gap);
+
+
+	.error {
+		color: var(--error);
+		text-align: center;
+	}
+
+}
+
+textarea {
+	outline: none;
+	border: none;
+	background: var(--secondary);
+	padding: var(--small-gap);
+	padding-top: calc(var(--small-gap) * 1.5);
+	font-family: var(--monospace);
+	resize: none;
+	tab-size: 4;
+}
+
+pre {
+	background: var(--secondary);
+	padding: var(--small-gap);
+	padding-top: calc(var(--small-gap) * 1.5);
+	margin: 0px;
+	font-family: var(--monospace);
+	tab-size: 4;
+	overflow-x: auto;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+input {
+	font-size: inherit;
+	outline: none;
+	border: none;
+	background: var(--secondary);
+	padding: var(--small-gap);
+}
+
+input:is(:hover, :focus) {
+	background: var(--primary);
+}
+
+button {
+	border: none;
+	outline: none;
+	font-size: inherit;
+	background: var(--secondary);
+}
+
+button:hover:not(:active) {
+	background: var(--primary);
+}
+
+code {
+	font-family: var(--monospace);
+	line-height: 1;
+}
+
+div#code-editor {
+	display: flex;
+	position: relative;
+
+	textarea {
+		flex: 1;
+	}
+
+	span#code-size {
+		position: absolute;
+		right: 2px;
+		font-size: 12px;
+	}
+}
+
+div#dep-list {
+	display: flex;
+	flex-direction: column;
+	align-items: center;
+	gap: var(--small-gap);
+
+	section {
+		width: 100%;
+		display: flex;
+		flex-direction: column;
+		text-align: center;
+		gap: var(--small-gap);
+
+		div {
+			text-align: left;
+		}
+	}
+}
+
+.syn {
+	font-family: var(--monospace);
+
+	&.Comment {
+		color: #939f91;
+	}
+
+	&.Keyword {
+		color: #f85552;
+	}
+
+	&.Identifier,
+	&.Directive {
+		color: #3a94c5;
+	}
+
+	/* &.Number {} */
+
+	&.String {
+		color: #8da101;
+	}
+
+	&.Op,
+	&.Assign {
+		color: #f57d26;
+	}
+
+	&.Paren,
+	&.Bracket,
+	&.Comma,
+	&.Dot,
+	&.Ctor,
+	&.Colon {
+		color: light-dark(#5c6a72, #999999);
+	}
+}

depell/src/index.js

@@ -0,0 +1,554 @@
+/// @ts-check
+
+/** @return {never} */
+function never() { throw new Error() }
+
+/**@type{WebAssembly.Instance}*/ let hbcInstance;
+/**@type{Promise<WebAssembly.WebAssemblyInstantiatedSource>}*/ let hbcInstaceFuture;
+async function getHbcInstance() {
+	hbcInstaceFuture ??= WebAssembly.instantiateStreaming(fetch("/hbc.wasm"), {});
+	return hbcInstance ??= (await hbcInstaceFuture).instance;
+}
+
+const stack_pointer_offset = 1 << 20;
+
+/** @param {WebAssembly.Instance} instance @param {Post[]} packages @param {number} fuel
+ * @returns {string} */
+function compileCode(instance, packages, fuel = 100) {
+	let {
+		INPUT, INPUT_LEN,
+		LOG_MESSAGES, LOG_MESSAGES_LEN,
+		memory, compile_and_run,
+	} = instance.exports;
+
+	if (!(true
+		&& memory instanceof WebAssembly.Memory
+		&& INPUT instanceof WebAssembly.Global
+		&& INPUT_LEN instanceof WebAssembly.Global
+		&& LOG_MESSAGES instanceof WebAssembly.Global
+		&& LOG_MESSAGES_LEN instanceof WebAssembly.Global
+		&& typeof compile_and_run === "function"
+	)) never();
+
+	const codeLength = packPosts(packages, new DataView(memory.buffer, INPUT.value));
+	new DataView(memory.buffer).setUint32(INPUT_LEN.value, codeLength, true);
+
+	runWasmFunction(instance, compile_and_run, fuel);
+	return bufToString(memory, LOG_MESSAGES, LOG_MESSAGES_LEN).trim();
+}
+
+/**@type{WebAssembly.Instance}*/ let fmtInstance;
+/**@type{Promise<WebAssembly.WebAssemblyInstantiatedSource>}*/ let fmtInstaceFuture;
+async function getFmtInstance() {
+	fmtInstaceFuture ??= WebAssembly.instantiateStreaming(fetch("/hbfmt.wasm"), {});
+	return fmtInstance ??= (await fmtInstaceFuture).instance;
+}
+
+/** @param {WebAssembly.Instance} instance @param {string} code @param {"tok" | "fmt" | "minify"} action
+ * @returns {string | Uint8Array | undefined} */
+function modifyCode(instance, code, action) {
+	let {
+		INPUT, INPUT_LEN,
+		OUTPUT, OUTPUT_LEN,
+		memory, fmt, tok, minify
+	} = instance.exports;
+
+	let funs = { fmt, tok, minify };
+	let fun = funs[action];
+	if (!(true
+		&& memory instanceof WebAssembly.Memory
+		&& INPUT instanceof WebAssembly.Global
+		&& INPUT_LEN instanceof WebAssembly.Global
+		&& OUTPUT instanceof WebAssembly.Global
+		&& OUTPUT_LEN instanceof WebAssembly.Global
+		&& funs.hasOwnProperty(action)
+		&& typeof fun === "function"
+	)) never();
+
+	if (action !== "fmt") {
+		INPUT = OUTPUT;
+		INPUT_LEN = OUTPUT_LEN;
+	}
+
+	let dw = new DataView(memory.buffer);
+	dw.setUint32(INPUT_LEN.value, code.length, true);
+	new Uint8Array(memory.buffer, INPUT.value).set(new TextEncoder().encode(code));
+
+	if (!runWasmFunction(instance, fun)) {
+		return undefined;
+	}
+	if (action === "tok") {
+		return bufSlice(memory, OUTPUT, OUTPUT_LEN);
+	} else {
+		return bufToString(memory, OUTPUT, OUTPUT_LEN);
+	}
+}
+
+
+/** @param {WebAssembly.Instance} instance @param {CallableFunction} func @param {any[]} args
+ * @returns {boolean} */
+function runWasmFunction(instance, func, ...args) {
+	const { PANIC_MESSAGE, PANIC_MESSAGE_LEN, memory, stack_pointer } = instance.exports;
+	if (!(true
+		&& memory instanceof WebAssembly.Memory
+		&& stack_pointer instanceof WebAssembly.Global
+	)) never();
+	const ptr = stack_pointer.value;
+	try {
+		func(...args);
+		return true;
+	} catch (error) {
+		if (error instanceof WebAssembly.RuntimeError
+			&& error.message == "unreachable"
+			&& PANIC_MESSAGE instanceof WebAssembly.Global
+			&& PANIC_MESSAGE_LEN instanceof WebAssembly.Global) {
+			console.error(bufToString(memory, PANIC_MESSAGE, PANIC_MESSAGE_LEN), error);
+		} else {
+			console.error(error);
+		}
+		stack_pointer.value = ptr;
+		return false;
+	}
+}
+
+/** @typedef {Object} Post
+ * @property {string} path 
+ * @property {string} code */
+
+/** @param {Post[]} posts @param {DataView} view  @returns {number} */
+function packPosts(posts, view) {
+	const enc = new TextEncoder(), buf = new Uint8Array(view.buffer, view.byteOffset);
+	let len = 0; for (const post of posts) {
+		view.setUint16(len, post.path.length, true); len += 2;
+		buf.set(enc.encode(post.path), len); len += post.path.length;
+		view.setUint16(len, post.code.length, true); len += 2;
+		buf.set(enc.encode(post.code), len); len += post.code.length;
+	}
+	return len;
+}
+
+/** @param {WebAssembly.Memory} mem
+ * @param {WebAssembly.Global} ptr
+ * @param {WebAssembly.Global} len
+ * @return {Uint8Array} */
+function bufSlice(mem, ptr, len) {
+	return new Uint8Array(mem.buffer, ptr.value,
+		new DataView(mem.buffer).getUint32(len.value, true));
+}
+
+/** @param {WebAssembly.Memory} mem
+ * @param {WebAssembly.Global} ptr
+ * @param {WebAssembly.Global} len
+ * @return {string} */
+function bufToString(mem, ptr, len) {
+	const res = new TextDecoder()
+		.decode(new Uint8Array(mem.buffer, ptr.value,
+			new DataView(mem.buffer).getUint32(len.value, true)));
+	new DataView(mem.buffer).setUint32(len.value, 0, true);
+	return res;
+}
+
+/** @param {HTMLElement} target */
+function wireUp(target) {
+	execApply(target);
+	cacheInputs(target);
+	bindCodeEdit(target);
+	bindTextareaAutoResize(target);
+}
+
+const importRe = /@use\s*\(\s*"(([^"]|\\")+)"\s*\)/g;
+
+/** @param {WebAssembly.Instance} fmt 
+ * @param {string} code
+ * @param {string[]} roots
+ * @param {Post[]} buf
+ * @param {Set<string>} prevRoots
+ * @returns {void} */
+function loadCachedPackages(fmt, code, roots, buf, prevRoots) {
+	buf[0].code = code;
+
+	roots.length = 0;
+	let changed = false;
+	for (const match of code.matchAll(importRe)) {
+		changed ||= !prevRoots.has(match[1]);
+		roots.push(match[1]);
+	}
+
+	if (!changed) return;
+	buf.length = 1;
+	prevRoots.clear();
+
+	for (let imp = roots.pop(); imp !== undefined; imp = roots.pop()) {
+		if (prevRoots.has(imp)) continue; prevRoots.add(imp);
+
+		const fmtd = modifyCode(fmt, localStorage.getItem("package-" + imp) ?? never(), "fmt");
+		if (typeof fmtd != "string") never();
+		buf.push({ path: imp, code: fmtd });
+		for (const match of buf[buf.length - 1].code.matchAll(importRe)) {
+			roots.push(match[1]);
+		}
+	}
+}
+
+/**@type{Set<string>}*/ const prevRoots = new Set();
+/**@typedef {Object} PackageCtx
+ * @property {AbortController} [cancelation]
+ * @property {string[]} keyBuf
+ * @property {Set<string>} prevParams
+ * @property {HTMLTextAreaElement} [edit] */
+
+/** @param {string} source @param {Set<string>} importDiff @param {HTMLPreElement} errors @param {PackageCtx} ctx */
+async function fetchPackages(source, importDiff, errors, ctx) {
+	importDiff.clear();
+	for (const match of source.matchAll(importRe)) {
+		if (localStorage["package-" + match[1]]) continue;
+		importDiff.add(match[1]);
+	}
+
+	if (importDiff.size !== 0 && (ctx.prevParams.size != importDiff.size
+		|| [...ctx.prevParams.keys()].every(e => importDiff.has(e)))) {
+		if (ctx.cancelation) ctx.cancelation.abort();
+		ctx.prevParams.clear();
+		ctx.prevParams = new Set([...importDiff]);
+		ctx.cancelation = new AbortController();
+
+		ctx.keyBuf.length = 0;
+		ctx.keyBuf.push(...importDiff.keys());
+
+		errors.textContent = "fetching: " + ctx.keyBuf.join(", ");
+
+		await fetch(`/code`, {
+			method: "POST",
+			signal: ctx.cancelation.signal,
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(ctx.keyBuf),
+		}).then(async e => {
+			try {
+				const json = await e.json();
+				if (e.status == 200) {
+					for (const [key, value] of Object.entries(json)) {
+						localStorage["package-" + key] = value;
+					}
+					const missing = ctx.keyBuf.filter(i => json[i] === undefined);
+					if (missing.length !== 0) {
+						errors.textContent = "deps not found: " + missing.join(", ");
+					} else {
+						ctx.cancelation = undefined;
+						ctx.edit?.dispatchEvent(new InputEvent("input"));
+					}
+				}
+			} catch (er) {
+				errors.textContent = "completely failed to fetch ("
+					+ e.status + "): " + ctx.keyBuf.join(", ");
+				console.error(e, er);
+			}
+		});
+	}
+
+}
+
+/** @param {HTMLElement} target */
+async function bindCodeEdit(target) {
+	const edit = target.querySelector("#code-edit");
+	if (!(edit instanceof HTMLTextAreaElement)) return;
+
+	const codeSize = target.querySelector("#code-size");
+	const errors = target.querySelector("#compiler-output");
+	if (!(true
+		&& codeSize instanceof HTMLSpanElement
+		&& errors instanceof HTMLPreElement
+	)) never();
+
+	const MAX_CODE_SIZE = parseInt(codeSize.innerHTML);
+	if (Number.isNaN(MAX_CODE_SIZE)) never();
+
+	const hbc = await getHbcInstance(), fmt = await getFmtInstance();
+	let importDiff = new Set();
+	/**@type{Post[]}*/
+	const packages = [{ path: "local.hb", code: "" }];
+	const debounce = 100;
+	let timeout = 0;
+	const ctx = { keyBuf: [], prevParams: new Set(), edit };
+
+	prevRoots.clear();
+
+	const onInput = () => {
+		fetchPackages(edit.value, importDiff, errors, ctx);
+
+		if (ctx.cancelation && importDiff.size !== 0) {
+			return;
+		}
+
+		loadCachedPackages(fmt, edit.value, ctx.keyBuf, packages, prevRoots);
+
+		errors.textContent = compileCode(hbc, packages);
+		const minified_size = modifyCode(fmt, edit.value, "minify")?.length;
+		if (minified_size) {
+			codeSize.textContent = (MAX_CODE_SIZE - minified_size) + "";
+			const perc = Math.min(100, Math.floor(100 * (minified_size / MAX_CODE_SIZE)));
+			codeSize.style.color = `color-mix(in srgb, light-dark(black, white), var(--error) ${perc}%)`;
+		}
+		timeout = 0;
+	};
+
+	edit.addEventListener("input", () => {
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(onInput, debounce)
+	});
+	edit.dispatchEvent(new InputEvent("input"));
+}
+
+/**
+ * @type {Array<string>}
+ * to be synched with `enum TokenGroup` in bytecode/src/fmt.rs */
+const TOK_CLASSES = [
+	'Blank',
+	'Comment',
+	'Keyword',
+	'Identifier',
+	'Directive',
+	'Number',
+	'String',
+	'Op',
+	'Assign',
+	'Paren',
+	'Bracket',
+	'Colon',
+	'Comma',
+	'Dot',
+	'Ctor',
+];
+
+/** @type {{ [key: string]: (el: HTMLElement) => void | Promise<void> }} */
+const applyFns = {
+	timestamp: (el) => {
+		const timestamp = el.innerText;
+		const date = new Date(parseInt(timestamp) * 1000);
+		el.innerText = date.toLocaleString();
+	},
+	fmt,
+};
+
+/**
+ * @param {HTMLElement} target */
+async function fmt(target) {
+	const code = target.innerText;
+	const instance = await getFmtInstance();
+	const decoder = new TextDecoder('utf-8');
+	const fmt = modifyCode(instance, code, 'fmt');
+	if (typeof fmt !== "string") return;
+	const codeBytes = new TextEncoder().encode(fmt);
+	const tok = modifyCode(instance, fmt, 'tok');
+	if (!(tok instanceof Uint8Array)) return;
+	target.innerHTML = '';
+	let start = 0;
+	let kind = tok[0];
+	for (let ii = 1; ii <= tok.length; ii += 1) {
+		// split over same tokens and buffer end
+		if (tok[ii] === kind && ii < tok.length) {
+			continue;
+		}
+		const text = decoder.decode(codeBytes.subarray(start, ii));
+		const textNode = document.createTextNode(text);;
+		if (kind === 0) {
+			target.appendChild(textNode);
+		} else {
+			const el = document.createElement('span');
+			el.classList.add('syn');
+			el.classList.add(TOK_CLASSES[kind]);
+			el.appendChild(textNode);
+			target.appendChild(el);
+		}
+		if (ii == tok.length) {
+			break;
+		}
+		start = ii;
+		kind = tok[ii];
+	}
+}
+
+/** @param {HTMLElement} target */
+function execApply(target) {
+	const proises = [];
+	for (const elem of target.querySelectorAll('[apply]')) {
+		if (!(elem instanceof HTMLElement)) continue;
+		const funcname = elem.getAttribute('apply') ?? never();
+		const vl = applyFns[funcname](elem);
+		if (vl instanceof Promise) proises.push(vl);
+	}
+	if (target === document.body) {
+		Promise.all(proises).then(() => document.body.hidden = false);
+	}
+}
+
+/** @param {HTMLElement} target */
+function bindTextareaAutoResize(target) {
+	for (const textarea of target.querySelectorAll("textarea")) {
+		if (!(textarea instanceof HTMLTextAreaElement)) never();
+
+		const taCssMap = window.getComputedStyle(textarea);
+		const padding = parseInt(taCssMap.getPropertyValue('padding-top') ?? "0")
+			+ parseInt(taCssMap.getPropertyValue('padding-top') ?? "0");
+		textarea.style.height = "auto";
+		textarea.style.height = (textarea.scrollHeight - padding) + "px";
+		textarea.style.overflowY = "hidden";
+		textarea.addEventListener("input", function() {
+			let top = window.scrollY;
+			textarea.style.height = "auto";
+			textarea.style.height = (textarea.scrollHeight - padding) + "px";
+			window.scrollTo({ top });
+		});
+
+		textarea.onkeydown = (ev) => {
+			if (ev.key === "Tab") {
+				ev.preventDefault();
+				document.execCommand('insertText', false, "\t");
+			}
+		}
+	}
+}
+
+/** @param {HTMLElement} target */
+function cacheInputs(target) {
+	/**@type {HTMLFormElement}*/ let form;
+	for (form of target.querySelectorAll('form')) {
+		const path = form.getAttribute('hx-post') || form.getAttribute('hx-delete');
+		if (!path) {
+			console.warn('form does not have a hx-post or hx-delete attribute', form);
+			continue;
+		}
+
+		for (const input of form.elements) {
+			if (input instanceof HTMLInputElement || input instanceof HTMLTextAreaElement) {
+				if ('password submit button'.includes(input.type)) continue;
+				const key = path + input.name;
+				input.value = localStorage.getItem(key) ?? '';
+				input.addEventListener("input", () => localStorage.setItem(key, input.value));
+			} else {
+				console.warn("unhandled form element: ", input);
+			}
+		}
+	}
+}
+
+/** @param {string} [path]  */
+function updateTab(path) {
+	console.log(path);
+	for (const elem of document.querySelectorAll("button[hx-push-url]")) {
+		if (elem instanceof HTMLButtonElement)
+			elem.disabled =
+				elem.getAttribute("hx-push-url") === path
+				|| elem.getAttribute("hx-push-url") === window.location.pathname;
+	}
+}
+
+if (window.location.hostname === 'localhost') {
+	let id; setInterval(async () => {
+		let new_id = await fetch('/hot-reload').then(reps => reps.text());
+		id ??= new_id;
+		if (id !== new_id) window.location.reload();
+	}, 300);
+
+	(async function test() {
+		{
+			const code = "main:=fn():void{return}";
+			const inst = await getFmtInstance()
+			const fmtd = modifyCode(inst, code, "fmt") ?? never();
+			if (typeof fmtd !== "string") never();
+			const prev = modifyCode(inst, fmtd, "minify") ?? never();
+			if (code != prev) console.error(code, prev);
+		}
+		{
+			const posts = [{
+				path: "foo.hb",
+				code: "main:=fn():int{return 42}",
+			}];
+			const res = compileCode(await getHbcInstance(), posts, 1) ?? never();
+			const expected = "exit code: 42";
+			if (expected != res) console.error(expected, res);
+		}
+	})()
+}
+
+document.body.addEventListener('htmx:afterSwap', (ev) => {
+	if (!(ev.target instanceof HTMLElement)) never();
+	wireUp(ev.target);
+	if (ev.target.tagName == "MAIN" || ev.target.tagName == "BODY")
+		updateTab(ev['detail'].pathInfo.finalRequestPath);
+});
+
+getFmtInstance().then(inst => {
+	document.body.addEventListener('htmx:configRequest', (ev) => {
+		const details = ev['detail'];
+		if (details.path === "/post" && details.verb === "post") {
+			details.parameters['code'] = modifyCode(inst, details.parameters['code'], "minify");
+		}
+	});
+
+	/** @param {string} query @param {string} target @returns {number} */
+	function fuzzyCost(query, target) {
+		let qi = 0, bi = 0, cost = 0, matched = false;
+		while (qi < query.length) {
+			if (query.charAt(qi) === target.charAt(bi++)) {
+				matched = true;
+				qi++;
+			} else {
+				cost++;
+			}
+			if (bi === target.length) (bi = 0, qi++);
+		}
+		return cost + (matched ? 0 : 100 * target.length);
+	}
+
+	let deps = undefined;
+	/** @param {HTMLInputElement} input @returns {void} */
+	function filterCodeDeps(input) {
+		deps ??= document.getElementById("deps");
+		if (!(deps instanceof HTMLElement)) never();
+		if (input.value === "") {
+			deps.textContent = "results show here...";
+			return;
+		}
+		deps.innerHTML = "";
+		for (const root of [...prevRoots.keys()]
+			.sort((a, b) => fuzzyCost(input.value, a) - fuzzyCost(input.value, b))) {
+			const pane = document.createElement("div");
+			const code = modifyCode(inst, localStorage["package-" + root], "fmt");
+			pane.innerHTML = `<div>${root}</div><pre>${code}</pre>`;
+			deps.appendChild(pane);
+		}
+		if (deps.innerHTML === "") {
+			deps.textContent = "no results";
+		}
+	}
+
+	Object.assign(window, { filterCodeDeps });
+});
+
+/** @param {HTMLElement} target  */
+function runPost(target) {
+	while (!target.matches("div[class=preview]")) target = target.parentElement ?? never();
+	const code = target.querySelector("pre[apply=fmt]");
+	if (!(code instanceof HTMLPreElement)) never();
+	const output = target.querySelector("pre[id=compiler-output]");
+	if (!(output instanceof HTMLPreElement)) never();
+
+	Promise.all([getHbcInstance(), getFmtInstance()]).then(async ([hbc, fmt]) => {
+		const ctx = { keyBuf: [], prevParams: new Set() };
+		await fetchPackages(code.innerText ?? never(), new Set(), output, ctx);
+		const posts = [{ path: "this", code: "" }];
+		loadCachedPackages(fmt, code.innerText ?? never(), ctx.keyBuf, posts, new Set());
+		output.textContent = compileCode(hbc, posts);
+		output.hidden = false;
+	});
+
+	let author = encodeURIComponent(target.dataset.author ?? never());
+	let name = encodeURIComponent(target.dataset.name ?? never());
+	fetch(`/post/run?author=${author}&name=${name}`, { method: "POST" })
+}
+
+Object.assign(window, { runPost });
+
+updateTab();
+wireUp(document.body);
+

depell/src/migrations/1.sql

@@ -0,0 +1 @@
+

depell/src/schema.sql

@@ -0,0 +1,55 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS user(
+	name TEXT NOT NULL,
+	password_hash TEXT NOT NULL,
+	PRIMARY KEY (name)
+) WITHOUT ROWID;
+
+CREATE TABLE IF NOT EXISTS session(
+	id BLOB NOT NULL,
+	username TEXT NOT NULL,
+	expiration INTEGER NOT NULL,
+	FOREIGN KEY (username) REFERENCES user (name)
+	PRIMARY KEY (username)
+) WITHOUT ROWID;
+
+CREATE UNIQUE INDEX IF NOT EXISTS
+	session_id ON session (id);
+
+CREATE TABLE IF NOT EXISTS post(
+	name TEXT NOT NULL,
+	author TEXT,
+	timestamp INTEGER,
+	code TEXT NOT NULL,
+	FOREIGN KEY (author) REFERENCES user(name) ON DELETE SET NULL,
+	PRIMARY KEY (author, name)
+);
+
+CREATE INDEX IF NOT EXISTS
+	post_timestamp ON post(timestamp DESC);
+
+CREATE TABLE IF NOT EXISTS import(
+	from_name TEXT NOT NULL,
+	from_author TEXT,
+	to_name TEXT NOT NULL,
+	to_author TEXT,
+	FOREIGN KEY (from_name, from_author) REFERENCES post(name, author),
+	FOREIGN KEY (to_name, to_author) REFERENCES post(name, author)
+);
+
+CREATE INDEX IF NOT EXISTS
+	dependencies ON import(from_name, from_author);
+
+CREATE INDEX IF NOT EXISTS
+	dependants ON import(to_name, to_author);
+
+CREATE TABLE IF NOT EXISTS run(
+	code_name TEXT NOT NULL,
+	code_author TEXT NOT NULL,
+	runner TEXT NOT NULL,
+	FOREIGN KEY (code_name, code_author) REFERENCES post(name, author),
+	FOREIGN KEY (runner) REFERENCES user(name),
+	PRIMARY KEY (code_name, code_author, runner)
+);
+

depell/src/static-pages/developing-hblang.md

@@ -0,0 +1,61 @@
+# The journey to an optimizing compiler
+
+It's been years since I was continuously trying to make a compiler to implement language of my dreams. Problem was tho that I wanted something similar to Rust, which if you did not know, `rustc` far exceeded the one million lines of code mark some time ago, so implementing such language would take me years if not decades, but I still tired it.
+
+Besides being extremely ambitions, the problem with my earliest attempts at making a compiler, is that literally nobody, not even me, was using the language, and so retroactively I am confident, what I implemented was a complex test-case implementation, and not a compiler. I often fall into a trap of implementing edge cases instead of an algorithm that would handle not only the very few thing the tests do but also all the other stuff that users of the language would try.
+
+Another part of why I was failing for all that time, is that I did the hardest thing first without understanding the core concepts involved in translating written language to IR, god forbid assembly. I wasted a lot of time like this, but at least I learned Rust well. At some point I found a job where I started developing a decentralized network and that fully drawn me away from language development.
+
+## Completely new approach
+
+At some point the company I was working for started having financial issues and they were unable to pay me. During that period, I discovered that my love for networking was majorly fueled by the monetary gains associated with it. I burned out, and started to look for things to do with the free time.
+
+One could say timing was perfect because [`ableos`](https://git.ablecorp.us/AbleOS/ableos) was desperately in need of a sane programming language that compiles to the home made VM ISA used for all software ran in `ableos`, but there was nobody crazy enough to do this. I got terribly nerd sniped, tho I don't regret it. Process of making a language for `ableos` was completely different. Firstly, it needed to be done asap, the lack of a good language blocked everyone form writing drivers for `ableos`, secondly, the moment the language is at least a little bit usable, people other then me will start using it, and lastly, the ISA the language compiles to very simple to emit, understand, and run.
+
+### Urgency is a bliss
+
+I actually managed to make the language somewhat work in one week, mainly because my mind set changed. I no longer spent a lot of time designing syntax for elegance, I designed it so that it incredibly easy to parse, meaning I can spent minimal effort implementing the parser, and fully focus on the hard problem of translating AST to instructions. Surprisingly, making everything an expression and not enforcing any arbitrary rules, makes the code you can write incredibly flexible and (most) people love it. One of the decisions I made to save time (or maybe it was an accident) was to make `,;` not enforced, meaning, you are allowed to write delimiters in lists but, as long as it does not change the intent of the code, you can leave them out. In practice, you actually don't need semicolons, unless the next line starts with something sticky like `*x`, int that case you put a semicolon on the previous line to tell the parser where the current expression ends.
+
+### Only the problem I care about
+
+Its good to note that writing a parser is no longer interesting for me. I wrote many parsers before and writing one no longer feel rewarding, but more like a chore. The real problem I was excited about was translating AST to instructions, I always ended up overcomplicating this step wit edge cases for every possible scenario that can happen in code, for which there are infinite. But why did I succeed this time? Well all the friction related to getting something that I can execute was so low, I could iterate quickly and realize what I am doing wrong before I burn out. In a week I managed to understand what I was failing to do for years, partly because of all the previous suffering, but mainly because it was so easy to pivot and try new things. And so I managed to make my first single pass compiler, and people immediately started using it.
+
+### Don't implement features nobody asked for
+
+Immediately after someone else then me wrote something in `hb` stuff started breaking, over the course of a month I kept fixing bugs and adding new features just fine, and more people started to use the language. All was good and well until I looked into the code. It was incredibly cursed, full of tricks to work around the compiler not doing any optimizations. At that moment I realized the whole compiler after parser needs to be rewritten, I had to implement optimizations, otherwise people wont be able to write readable code that runs fast. All of the features I have added up until now, were a technical dept now. Unless they are all working with optimizations, can't compile the existing code. Yes, if feature exists, be sure as hell it will be used.
+
+It took around 4 months to reimplement everything make make the optimal code look like what you are used to in other languages. I am really thankful for [sea of nodes](https://github.com/SeaOfNodes), and all the amazing work Cliff Click and others do to make demystify optimizers, It would have taken much longer to for me to figure all the principles out without the exhaustive [tutorial](https://github.com/SeaOfNodes/Simple?tab=readme-ov-file).
+
+## How my understanding of optimizations changed
+
+### Optimizations allow us to scale software
+
+I need to admit, before writing a single pass compiler and later upgrading it to optimizing one, I thought optimizations only affect the quality of final assembly emitted by the compiler. It never occur to me that what the optimizations actually do, is reduce the impact of how you decide to write the code. In a single pass compiler (with zero optimizations), the machine code reflects:
+
+- order of operations as written in code
+- whether the value was stored in intermediate locations
+- exact structure of the control flow and at which point the operations are placed
+- how many times is something recomputed
+- operations that only help to convey intent for the reader of the source code
+- and more I can't think of...
+
+If you took some code you wrote and then modified it to obfuscate these aspects (in reference to the original code), you would to a subset of what optimizing compiler does. Of course, a good compiler would try hard to improve the metrics its optimizing for, it would:
+
+- reorder operations to allow the CPU to parallelize them
+- remove needless stores, or store values directly to places you cant express in code
+- pull operations out of the loops and into the branches (if it can)
+- find all common sub-expressions and compute them only once
+- fold constants as much as possible and use obscure tricks to replace slow instructions if any of the operands are constant
+- and more...
+
+In the end, compiler optimizations try to reduce correlation between how the code happens to be written and how well it performs, which is extremely important when you want humans to read the code.
+
+### Optimizing compilers know more then you
+
+Optimizing code is a search problem, an optimizer searches the code for patterns that can be rewritten so something more practical for the computer, while preserving the observable behavior of the program. This means it needs enough context about the code to not make a mistake. In fact, the optimizer has so much context, it is able to determine your code is useless. But wait, didn't you write the code because you needed it to do something? Maybe your intention was to break out of the loop after you are done, but the optimizer looked at the code and said, "great, we are so lucky that this integer is always small enough to miss this check by one, DELETE", and then he goes "jackpot, since this loop is now infinite, we don't need this code after it, DELETE". Notice that the optimizer is eager to delete dead code, it did not ask you "Brah, why did you place all your code after an infinite loop?". This is just an example, there are many more cases where modern optimizers just delete all your code because they proven it does something invalid without running it.
+
+Its stupid but its the world we live in, optimizers are usually a black box you import and feed it the code in a format they understand, they then proceed to optimize it, and if they find a glaring bug they wont tell you, god forbid, they will just molest the code in unspecified ways and spit out whats left. Before writing an optimizer, I did no know this can happen and I did not know this is a problem I pay for with my time, spent figuring out why noting is happening when I run the program.
+
+But wait its worse! Since optimizers wont ever share the fact you are stupid, we end up with other people painstakingly writing complex linters, that will do a shitty job detecting things that matter, and instead whine about style and other bullcrap (and they suck even at that). If the people who write linters and people who write optimizers swapped the roles, I would be ranting about optimizers instead.
+
+And so, this is the area where I want to innovate, lets report the dead code to the frontend, and let the compiler frontend filter out the noise and show relevant information in the diagnostics. Refuse to compile the program if you `i /= 0`. Refuse to compile if you `arr[arr.len]`. This is the level of stupid optimizer sees, once it normalizes your code, but proceeds to protect your feelings. My goal so for hblang to relay this to you as much as possible. If we can query for optimizations, we can query for bugs too.

depell/src/static-pages/post.md

@@ -0,0 +1,8 @@
+### About posting code
+
+If you are unfammiliar with [hblang](https://git.ablecorp.us/AbleOS/holey-bytes), refer to the **hblang/README.md** or vizit [mlokis'es posts](/profile/mlokis). Preferably don't edit the code here.
+
+### Extra textarea features
+
+- proper tab behaviour
+- snap to previous tab boundary on "empty" lines

depell/src/static-pages/welcome.md

@@ -0,0 +1,11 @@
+## Welcome to depell
+
+Depell (dependency hell) is a simple "social" media site, except that all you can post is [hblang](https://git.ablecorp.us/AbleOS/holey-bytes) code. Instead of likes you run the program, and instead of mentions you import the program as dependency. Run counts even when ran indirectly.
+
+The backend only serves the code and frontend compiles and runs it locally. All posts are immutable.
+
+## Security?
+
+All code runs in WASM (inside a holey-bytes VM until hblang compiles to wasm) and is controlled by JavaScript. WASM
+cant do any form of IO without going trough JavaScript so as long as JS import does not allow wasm to execute
+arbitrary JS code, WASM can act as a container inside the JS.

depell/wasm-fmt/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "wasm-hbfmt"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+hblang = { workspace = true, features = ["no_log"] }
+wasm-rt = { version = "0.1.0", path = "../wasm-rt" }

depell/wasm-fmt/src/lib.rs

@@ -0,0 +1,42 @@
+#![no_std]
+#![feature(str_from_raw_parts)]
+#![feature(alloc_error_handler)]
+
+use hblang::{fmt, parser};
+
+wasm_rt::decl_runtime!(128 * 1024, 1024 * 4);
+
+const MAX_OUTPUT_SIZE: usize = 1024 * 10;
+wasm_rt::decl_buffer!(MAX_OUTPUT_SIZE, MAX_OUTPUT, OUTPUT, OUTPUT_LEN);
+
+const MAX_INPUT_SIZE: usize = 1024 * 4;
+wasm_rt::decl_buffer!(MAX_INPUT_SIZE, MAX_INPUT, INPUT, INPUT_LEN);
+
+#[no_mangle]
+unsafe extern "C" fn fmt() {
+    ALLOCATOR.reset();
+
+    let code = core::str::from_raw_parts(core::ptr::addr_of!(INPUT).cast(), INPUT_LEN);
+
+    let arena = parser::Arena::with_capacity(code.len() * parser::SOURCE_TO_AST_FACTOR);
+    let mut ctx = parser::Ctx::default();
+    let exprs = parser::Parser::parse(&mut ctx, code, "source.hb", &mut parser::no_loader, &arena);
+
+    let mut f = wasm_rt::Write(&mut OUTPUT[..]);
+    fmt::fmt_file(exprs, code, &mut f).unwrap();
+    OUTPUT_LEN = MAX_OUTPUT_SIZE - f.0.len();
+}
+
+#[no_mangle]
+unsafe extern "C" fn tok() {
+    let code = core::slice::from_raw_parts_mut(
+        core::ptr::addr_of_mut!(OUTPUT).cast(), OUTPUT_LEN);
+    OUTPUT_LEN = fmt::get_token_kinds(code);
+}
+
+#[no_mangle]
+unsafe extern "C" fn minify() {
+    let code = core::str::from_raw_parts_mut(
+        core::ptr::addr_of_mut!(OUTPUT).cast(), OUTPUT_LEN);
+    OUTPUT_LEN = fmt::minify(code);
+}

depell/wasm-hbc/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "wasm-hbc"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+hblang = { workspace = true, features = [] }
+hbvm.workspace = true
+log = { version = "0.4.22", features = ["release_max_level_error"] }
+wasm-rt = { version = "0.1.0", path = "../wasm-rt", features = ["log"] }
+

depell/wasm-hbc/src/lib.rs

@@ -0,0 +1,128 @@
+#![feature(alloc_error_handler)]
+#![feature(slice_take)]
+#![no_std]
+
+use {
+    alloc::{string::String, vec::Vec},
+    core::ffi::CStr,
+    hblang::{
+        backend::hbvm::HbvmBackend,
+        son::{Codegen, CodegenCtx},
+        ty::Module,
+        utils::Ent,
+    },
+};
+
+extern crate alloc;
+
+const ARENA_CAP: usize = 128 * 16 * 1024;
+wasm_rt::decl_runtime!(ARENA_CAP, 1024 * 4);
+
+const MAX_INPUT_SIZE: usize = 32 * 4 * 1024;
+wasm_rt::decl_buffer!(MAX_INPUT_SIZE, MAX_INPUT, INPUT, INPUT_LEN);
+
+#[no_mangle]
+unsafe fn compile_and_run(mut fuel: usize) {
+    ALLOCATOR.reset();
+
+    _ = log::set_logger(&wasm_rt::Logger);
+    log::set_max_level(log::LevelFilter::Error);
+
+    struct File<'a> {
+        path: &'a str,
+        code: &'a mut str,
+    }
+
+    let mut root = 0;
+
+    let files = {
+        let mut input_bytes =
+            core::slice::from_raw_parts_mut(core::ptr::addr_of_mut!(INPUT).cast::<u8>(), INPUT_LEN);
+
+        let mut files = Vec::with_capacity(32);
+        while let Some((&mut path_len, rest)) = input_bytes.split_first_chunk_mut() {
+            let (path, rest) = rest.split_at_mut(u16::from_le_bytes(path_len) as usize);
+            let (&mut code_len, rest) = rest.split_first_chunk_mut().unwrap();
+            let (code, rest) = rest.split_at_mut(u16::from_le_bytes(code_len) as usize);
+            files.push(File {
+                path: core::str::from_utf8_unchecked(path),
+                code: core::str::from_utf8_unchecked_mut(code),
+            });
+            input_bytes = rest;
+        }
+
+        let root_path = files[root].path;
+        hblang::quad_sort(&mut files, |a, b| a.path.cmp(b.path));
+        root = files.binary_search_by_key(&root_path, |p| p.path).unwrap();
+
+        files
+    };
+
+    let mut ctx = CodegenCtx::default();
+
+    let files = {
+        let paths = files.iter().map(|f| f.path).collect::<Vec<_>>();
+        let mut loader = |path: &str, _: &str, kind| match kind {
+            hblang::parser::FileKind::Module => Ok(paths.binary_search(&path).unwrap()),
+            hblang::parser::FileKind::Embed => Err("embeds are not supported".into()),
+        };
+        files
+            .into_iter()
+            .map(|f| {
+                hblang::parser::Ast::new(
+                    f.path,
+                    // since 'free' does nothing this is fine
+                    String::from_raw_parts(f.code.as_mut_ptr(), f.code.len(), f.code.len()),
+                    &mut ctx.parser,
+                    &mut loader,
+                )
+            })
+            .collect::<Vec<_>>()
+    };
+
+    let mut ct = {
+        let mut backend = HbvmBackend::default();
+        Codegen::new(&mut backend, &files, &mut ctx).generate(Module::new(root));
+
+        if !ctx.parser.errors.borrow().is_empty() {
+            log::error!("{}", ctx.parser.errors.borrow());
+            return;
+        }
+
+        let mut c = Codegen::new(&mut backend, &files, &mut ctx);
+        c.assemble_comptime()
+    };
+
+    while fuel != 0 {
+        match ct.vm.run() {
+            Ok(hbvm::VmRunOk::End) => {
+                log::error!("exit code: {}", ct.vm.read_reg(1).0 as i64);
+                break;
+            }
+            Ok(hbvm::VmRunOk::Ecall) => {
+                let kind = ct.vm.read_reg(2).0;
+                match kind {
+                    0 => {
+                        let str = ct.vm.read_reg(3).0;
+                        let str = unsafe { CStr::from_ptr(str as _) };
+                        log::error!("{}", str.to_str().unwrap());
+                    }
+                    unknown => log::error!("unknown ecall: {unknown}"),
+                }
+            }
+            Ok(hbvm::VmRunOk::Timer) => {
+                fuel -= 1;
+                if fuel == 0 {
+                    log::error!("program timed out");
+                }
+            }
+            Ok(hbvm::VmRunOk::Breakpoint) => todo!(),
+            Err(e) => {
+                log::error!("vm error: {e}");
+                break;
+            }
+        }
+    }
+
+    //log::error!("memory consumption: {}b / {}b", ALLOCATOR.used(), ARENA_CAP);
+}

depell/wasm-rt/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "wasm-rt"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+log = { version = "0.4.22", optional = true }

depell/wasm-rt/src/lib.rs

@@ -0,0 +1,162 @@
+#![feature(alloc_error_handler)]
+#![feature(pointer_is_aligned_to)]
+#![feature(slice_take)]
+#![no_std]
+
+use core::{
+    alloc::{GlobalAlloc, Layout},
+    cell::UnsafeCell,
+};
+
+extern crate alloc;
+
+#[macro_export]
+macro_rules! decl_buffer {
+    ($cap:expr, $export_cap:ident, $export_base:ident, $export_len:ident) => {
+        #[no_mangle]
+        static $export_cap: usize = $cap;
+        #[no_mangle]
+        static mut $export_base: [u8; $cap] = [0; $cap];
+        #[no_mangle]
+        static mut $export_len: usize = 0;
+    };
+}
+
+#[macro_export]
+macro_rules! decl_runtime {
+    ($memory_size:expr, $max_panic_size:expr) => {
+        #[cfg(debug_assertions)]
+        #[no_mangle]
+        static mut PANIC_MESSAGE: [u8; $max_panic_size] = [0; $max_panic_size];
+        #[cfg(debug_assertions)]
+        #[no_mangle]
+        static mut PANIC_MESSAGE_LEN: usize = 0;
+
+        #[cfg(target_arch = "wasm32")]
+        #[panic_handler]
+        pub fn handle_panic(_info: &core::panic::PanicInfo) -> ! {
+            #[cfg(debug_assertions)]
+            {
+                unsafe {
+                    use core::fmt::Write;
+                    let mut f = $crate::Write(&mut PANIC_MESSAGE[..]);
+                    _ = writeln!(f, "{}", _info);
+                    PANIC_MESSAGE_LEN = $max_panic_size - f.0.len();
+                }
+            }
+
+            core::arch::wasm32::unreachable();
+        }
+
+        #[global_allocator]
+        static ALLOCATOR: $crate::ArenaAllocator<{ $memory_size }> = $crate::ArenaAllocator::new();
+
+        #[cfg(target_arch = "wasm32")]
+        #[alloc_error_handler]
+        fn alloc_error(_: core::alloc::Layout) -> ! {
+            #[cfg(debug_assertions)]
+            {
+                unsafe {
+                    use core::fmt::Write;
+                    let mut f = $crate::Write(&mut PANIC_MESSAGE[..]);
+                    _ = writeln!(f, "out of memory");
+                    PANIC_MESSAGE_LEN = $max_panic_size - f.0.len();
+                }
+            }
+
+            core::arch::wasm32::unreachable()
+        }
+    };
+}
+
+#[cfg(feature = "log")]
+pub struct Logger;
+
+#[cfg(feature = "log")]
+impl log::Log for Logger {
+    fn enabled(&self, _: &log::Metadata) -> bool {
+        true
+    }
+
+    fn log(&self, record: &log::Record) {
+        if self.enabled(record.metadata()) {
+            const MAX_LOG_MESSAGE: usize = 1024 * 8;
+            #[no_mangle]
+            static mut LOG_MESSAGES: [u8; MAX_LOG_MESSAGE] = [0; MAX_LOG_MESSAGE];
+            #[no_mangle]
+            static mut LOG_MESSAGES_LEN: usize = 0;
+
+            unsafe {
+                use core::fmt::Write;
+                let mut f = Write(&mut LOG_MESSAGES[LOG_MESSAGES_LEN..]);
+                _ = writeln!(f, "{}", record.args());
+                LOG_MESSAGES_LEN = MAX_LOG_MESSAGE - f.0.len();
+            }
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+pub struct ArenaAllocator<const SIZE: usize> {
+    arena: UnsafeCell<[u8; SIZE]>,
+    head: UnsafeCell<*mut u8>,
+}
+
+impl<const SIZE: usize> ArenaAllocator<SIZE> {
+    #[expect(clippy::new_without_default)]
+    pub const fn new() -> Self {
+        ArenaAllocator {
+            arena: UnsafeCell::new([0; SIZE]),
+            head: UnsafeCell::new(core::ptr::null_mut()),
+        }
+    }
+
+    #[expect(clippy::missing_safety_doc)]
+    pub unsafe fn reset(&self) {
+        (*self.head.get()) = self.arena.get().cast::<u8>().add(SIZE);
+    }
+
+    pub fn used(&self) -> usize {
+        unsafe { self.arena.get() as usize + SIZE - (*self.head.get()) as usize }
+    }
+}
+
+unsafe impl<const SIZE: usize> Sync for ArenaAllocator<SIZE> {}
+
+unsafe impl<const SIZE: usize> GlobalAlloc for ArenaAllocator<SIZE> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let size = layout.size();
+        let align = layout.align();
+
+        let until = self.arena.get() as *mut u8;
+
+        let new_head = (*self.head.get()).sub(size);
+        let aligned_head = (new_head as usize & !(align - 1)) as *mut u8;
+        debug_assert!(aligned_head.is_aligned_to(align));
+
+        if until > aligned_head {
+            return core::ptr::null_mut();
+        }
+
+        *self.head.get() = aligned_head;
+        aligned_head
+    }
+
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+        /* lol */
+    }
+}
+
+pub struct Write<'a>(pub &'a mut [u8]);
+
+impl core::fmt::Write for Write<'_> {
+    fn write_str(&mut self, s: &str) -> core::fmt::Result {
+        if let Some(m) = self.0.take_mut(..s.len()) {
+            m.copy_from_slice(s.as_bytes());
+            Ok(())
+        } else {
+            Err(core::fmt::Error)
+        }
+    }
+}

examples/raylib/main.hb

@@ -0,0 +1,47 @@
+InitWindow := fn(w: uint, h: uint, name: ^u8): uint @import()
+WindowShouldClose := fn(): bool @import()
+BeginDrawing := fn(): void @import()
+EndDrawing := fn(): void @import()
+DrawRectangleV := fn(pos: Vec2, size: Vec2, color: Color): void @import()
+DrawRectangle := fn(a: uint, b: uint, c: uint, d: uint, color: Color): void @import()
+ClearBackground := fn(color: Color): void @import()
+SetTargetFPS := fn(target: uint): void @import()
+GetFrameTime := fn(): f32 @import()
+
+Vec2 := struct {x: f32, y: f32}
+Color := struct {r: u8, g: u8, b: u8, a: u8}
+
+$W := 800
+$H := 600
+
+main := fn(): uint {
+	_ = InitWindow(W, H, "whawee\0".ptr)
+
+	SetTargetFPS(60)
+
+	pos := Vec2.(100, 100)
+	vel := Vec2.(300, 300)
+	size := Vec2.(100, 100)
+	color := Color.(17, 255, 17, 255)
+
+	loop if WindowShouldClose() break else {
+		BeginDrawing()
+		ClearBackground(.(0, 0, 0, 255))
+
+		DrawRectangleV(pos, size, color)
+		pos += vel * .(GetFrameTime(), GetFrameTime())
+
+		if pos.x < 0 | pos.x + size.x > W {
+			vel.x *= -1
+			color += .(32, 11, 20, 0)
+		}
+
+		if pos.y < 0 | pos.y + size.y > H {
+			vel.y *= -1
+			color += .(32, 11, 20, 0)
+		}
+		EndDrawing()
+	}
+
+	return 0
+}

examples/raylib/run.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+DIR=$(dirname $0)
+cd $DIR
+cargo run -p hbc main.hb > out.o && gcc -o main out.o -lraylib -lm -ldl -lpthread -lrt -lGL -lX11 && ./main

hbjit/Cargo.toml

@@ -1,6 +0,0 @@
-[package]
-name = "hbjit"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]

hbjit/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}

hblang/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "hblang"
-version = "0.1.0"
-edition = "2021"
-
-[[bin]]
-name = "hbc"
-path = "src/main.rs"
-
-[dependencies]
-hbbytecode = { version = "0.1.0", path = "../hbbytecode" }
-hbvm = { path = "../hbvm", features = ["nightly"] }
-regalloc2 = { git = "https://github.com/jakubDoka/regalloc2" }

hblang/README.md

@@ -1,945 +0,0 @@
-# HERE SHALL THE DOCUMENTATION RESIDE
-
-## Enforced Political Views
-
-- worse is better
-- less is more
-- embrace `unsafe {}`
-- adhere `macro_rules!`
-- pessimization == death (put in `std::pin::Pin` and left with hungry crabs)
-- importing external dependencies == death (`fn(dependencies) -> ExecutionStrategy`)
-- above sell not be disputed, discussed, or questioned
-
-## What hblang is
-
-Holey-Bytes-Language (hblang for short) (*.hb) is the only true language targeting hbvm byte code. hblang is low level, manually managed, and procedural. Its rumored to be better then writing hbasm and you should probably use it for complex applications.
-
-## What hblang isnt't
-
-hblang knows what it isn't, because it knows what it is, hblang computes this by sub...
-
-
-## Examples
-
-Examples are also used in tests. To add an example that runs during testing add:
-<pre>
-#### &lt;name&gt
-```hb
-&lt;example&gt
-```
-</pre>
-and also:
-```rs
-<name> => README;
-```
-to the `run_tests` macro at the bottom of the `src/codegen.rs`.
-
-### Tour Examples
-
-Following examples incrementally introduce language features and syntax.
-
-#### main_fn
-```hb
-main := fn(): int {
-	return 1;
-}
-```
-
-#### arithmetic
-```hb
-main := fn(): int {
-	return 10 - 20 / 2 + 4 * (2 + 2) - 4 * 4 + (1 << 0) + -1
-}
-```
-
-#### functions
-```hb
-main := fn(): int {
-	return add_one(10) + add_two(20)
-}
-
-add_two := fn(x: int): int {
-	return x + 2
-}
-
-add_one := fn(x: int): int {
-	return x + 1
-}
-```
-
-#### comments
-```hb
-// commant is an item
-main := fn(): int {
-	// comment is a statement
-
-	foo(/* comment is an exprression /* if you are crazy */ */)
-	return 0
-}
-
-foo := fn(comment: void): void return /* comment evaluates to void */
-
-// comments might be formatted in the future
-```
-
-#### if_statements
-```hb
-main := fn(): int {
-	return fib(10)
-}
-
-fib := fn(x: int): int {
-	if x <= 2 {
-		return 1
-	} else {
-		return fib(x - 1) + fib(x - 2)
-	}
-}
-```
-
-#### variables
-```hb
-main := fn(): int {
-	ඞ := 1
-	b := 2
-	ඞ += 1
-	return ඞ - b
-}
-```
-
-#### loops
-```hb
-main := fn(): int {
-	return fib(10)
-}
-
-fib := fn(n: int): int {
-	a := 0
-	b := 1
-	loop if n == 0 break else {
-		c := a + b
-		a = b
-		b = c
-		n -= 1
-	}
-	return a
-}
-```
-
-#### pointers
-```hb
-main := fn(): int {
-	a := 1
-	b := &a
-	modify(b)
-	drop(a)
-	stack_reclamation_edge_case := 0
-	return *b - 2
-}
-
-modify := fn(a: ^int): void {
-	*a = 2
-	return
-}
-
-drop := fn(a: int): void {
-	return
-}
-```
-
-#### structs
-```hb
-Ty := struct {
-	// comment
-
-	a: int,
-	b: int,
-}
-
-Ty2 := struct {
-	ty: Ty,
-	c: int,
-}
-
-main := fn(): int {
-	finst := Ty2.{ty: Ty.{a: 4, b: 1}, c: 3}
-	inst := odher_pass(finst)
-	if inst.c == 3 {
-		return pass(&inst.ty)
-	}
-	return 0
-}
-
-pass := fn(t: ^Ty): int {
-	.{a, b} := *t
-	return a - b
-}
-
-odher_pass := fn(t: Ty2): Ty2 {
-	return t
-}
-```
-
-#### struct_operators
-```hb
-Point := struct {
-	x: int,
-	y: int,
-}
-
-Rect := struct {
-	a: Point,
-	b: Point,
-}
-
-main := fn(): int {
-	a := Point.(1, 2)
-	b := Point.(3, 4)
-
-	d := Rect.(a + b, b - a)
-	d2 := Rect.(Point.(0, 0) - b, a)
-	d2 += d
-
-	c := d2.a + d2.b
-	return c.x + c.y
-}
-```
-
-#### global_variables
-```hb
-global_var := 10
-
-complex_global_var := fib(global_var) - 5
-
-fib := fn(n: int): int {
-	if 2 > n {
-		return n
-	}
-	return fib(n - 1) + fib(n - 2)
-}
-
-main := fn(): int {
-	complex_global_var += 5
-	return complex_global_var
-}
-```
-note: values of global variables are evaluated at compile time
-
-#### directives
-```hb
-foo := @use("foo.hb")
-
-main := fn(): int {
-	byte := @as(u8, 10)
-	same_type_as_byte := @as(@TypeOf(byte), 30)
-	wide_uint := @as(u32, 40)
-	truncated_uint := @as(u8, @intcast(wide_uint))
-	size_of_Type_in_bytes := @sizeof(foo.Type)
-	align_of_Type_in_bytes := @alignof(foo.Type)
-	hardcoded_pointer := @as(^u8, @bitcast(10))
-	ecall_that_returns_int := @as(int, @eca(1, foo.Type.(10, 20), 5, 6))
-	return @inline(foo.foo)
-}
-
-// in module: foo.hb
-
-Type := struct {
-	brah: int,
-	blah: int,
-}
-
-foo := fn(): int return 0
-```
-
-- `@use(<string>)`: imports a module based of string, the string is passed to a loader that can be customized, default loader uses following syntax:
-	- `((rel:|)(<path>)|git:<git-addr>:<path>)`: `rel:` and `''` prefixes both mean module is located at `path` relavive to the current file, `git:` takes a git url without `https://` passed as `git-addr`, `path` then refers to file within the repository
-- `@TypeOf(<expr>)`: results into literal type of whatever the type of `<expr>` is, `<expr>` is not included in final binary
-- `@as(<ty>, <expr>)`: hint to the compiler that  `@TypeOf(<expr>) == <ty>`
-- `@intcast(<expr>)`: needs to be used when conversion of `@TypeOf(<expr>)` would loose precision (widening of integers is implicit)
-- `@sizeof(<ty>), @alignof(<ty>)`: I think explaining this would insult your intelligence
-- `@bitcast(<expr>)`: tell compiler to assume `@TypeOf(<expr>)` is whatever is inferred, so long as size and alignment did not change
-- `@eca(<ty>, ...<expr>)`: invoke `eca` instruction, where `<ty>` is the type this will return and `<expr>...` are arguments passed to the call
-- `@inline(<func>, ...<args>)`: equivalent to `<func>(...<args>)` but function is guaranteed to inline, compiler will otherwise never inline
-
-#### c_strings
-```hb
-str_len := fn(str: ^u8): int {
-	len := 0
-	loop if *str == 0 break else {
-		len += 1
-		str += 1
-	}
-	return len
-}
-
-main := fn(): int {
-	// when string ends with '\0' its a C string and thus type is '^u8'
-	some_str := "abඞ\n\r\t\{35}\{36373839}\0"
-	len := str_len(some_str)
-	some_other_str := "fff\0"
-	lep := str_len(some_other_str)
-	return lep + len
-}
-```
-
-#### struct_patterns
-```hb
-.{fib, fib_iter, Fiber} := @use("fibs.hb")
-
-main := fn(): int {
-	.{a, b} := Fiber.{a: 10, b: 10}
-	return fib(a) - fib_iter(b)
-}
-
-// in module: fibs.hb
-
-Fiber := struct {a: u8, b: u8}
-
-fib := fn(n: int): int if n < 2 {
-	return n
-} else {
-	return fib(n - 1) + fib(n - 2)
-}
-
-fib_iter := fn(n: int): int {
-	a := 0
-	b := 1
-	loop if n == 0 break else {
-		c := a + b
-		a = b
-		b = c
-		n -= 1
-	}
-	return a
-}
-```
-
-#### arrays
-```hb
-main := fn(): int {
-	addr := @as(u16, 0x1FF)
-	msg := [u8].(0, 0, @as(u8, addr & 0xFF), @as(u8, addr >> 8 & 0xFF))
-	_force_stack := &msg
-
-	arr := [int].(1, 2, 4)
-	return pass(&arr) + msg[3]
-}
-
-pass := fn(arr: ^[int; 3]): int {
-	return arr[0] + arr[1] + arr[arr[1]]
-}
-```
-
-#### inline
-```hb
-main := fn(): int {
-	return @inline(foo, 1, 2, 3) - 6
-}
-
-foo := fn(a: int, b: int, c: int): int {
-	return a + b + c
-}
-```
-
-#### idk
-```hb
-_edge_case := @as(int, idk)
-
-main := fn(): int {
-	big_array := @as([u8; 128], idk)
-	i := 0
-	loop if i >= 128 break else {
-		big_array[i] = 69
-		i += 1
-	}
-	return big_array[42]
-}
-```
-
-#### wide_ret
-```hb
-OemIdent := struct {
-	dos_version: [u8; 8],
-	dos_version_name: [u8; 8],
-}
-
-Stru := struct {
-	a: u16,
-	b: u16,
-}
-
-small_struct := fn(): Stru {
-	return .{a: 0, b: 0}
-}
-
-main := fn(major: int, minor: int): OemIdent {
-	small_struct()
-	ver := [u8].(0, 0, 0, 0, 0, 0, 0, 0)
-	return OemIdent.(ver, ver)
-}
-```
-
-### Incomplete Examples
-
-#### comptime_pointers
-```hb
-main := fn(): int {
-	$integer := 7
-	modify(&integer)
-	return integer
-}
-
-modify := fn($num: ^int): void {
-	$: *num = 0
-}
-```
-
-#### generic_types
-```hb
-MALLOC_SYS_CALL := 69
-FREE_SYS_CALL := 96
-
-malloc := fn(size: uint, align: uint): ^void return @eca(MALLOC_SYS_CALL, size, align)
-free := fn(ptr: ^void, size: uint, align: uint): void return @eca(FREE_SYS_CALL, ptr, size, align)
-
-Vec := fn($Elem: type): type {
-	return struct {
-		data: ^Elem,
-		len: uint,
-		cap: uint,
-	}
-}
-
-new := fn($Elem: type): Vec(Elem) return Vec(Elem).{data: @bitcast(0), len: 0, cap: 0}
-
-deinit := fn($Elem: type, vec: ^Vec(Elem)): void {
-	free(@bitcast(vec.data), vec.cap * @sizeof(Elem), @alignof(Elem));
-	*vec = new(Elem)
-	return
-}
-
-push := fn($Elem: type, vec: ^Vec(Elem), value: Elem): ^Elem {
-	if vec.len == vec.cap {
-		if vec.cap == 0 {
-			vec.cap = 1
-		} else {
-			vec.cap *= 2
-		}
-
-		new_alloc := @as(^Elem, @bitcast(malloc(vec.cap * @sizeof(Elem), @alignof(Elem))))
-		if new_alloc == 0 return 0
-
-		src_cursor := vec.data
-		dst_cursor := new_alloc
-		end := vec.data + vec.len
-
-		loop if src_cursor == end break else {
-			*dst_cursor = *src_cursor
-			src_cursor += 1
-			dst_cursor += 1
-		}
-
-		if vec.len != 0 {
-			free(@bitcast(vec.data), vec.len * @sizeof(Elem), @alignof(Elem))
-		}
-		vec.data = new_alloc
-	}
-
-	slot := vec.data + vec.len;
-	*slot = value
-	vec.len += 1
-	return slot
-}
-
-main := fn(): int {
-	vec := new(int)
-	push(int, &vec, 69)
-	res := *vec.data
-	deinit(int, &vec)
-	return res
-}
-```
-
-#### generic_functions
-```hb
-add := fn($T: type, a: T, b: T): T return a + b
-
-main := fn(): int {
-	return add(u32, 2, 2) - add(int, 1, 3)
-}
-```
-
-#### fb_driver
-```hb
-arm_fb_ptr := fn(): int return 100
-x86_fb_ptr := fn(): int return 100
-
-check_platform := fn(): int {
-	return x86_fb_ptr()
-}
-
-set_pixel := fn(x: int, y: int, width: int): int {
-	return y * width + x
-}
-
-main := fn(): int {
-	fb_ptr := check_platform()
-	width := 100
-	height := 30
-	x := 0
-	y := 0
-	//t := 0
-	i := 0
-
-	loop {
-		if x < height {
-			//t += set_pixel(x, y, height)
-			x += 1
-			i += 1
-		} else {
-			x = 0
-			y += 1
-			if set_pixel(x, y, height) != i return 0
-			if y == width break
-		}
-	}
-	return i
-}
-```
-
-### Purely Testing Examples
-
-#### comptime_min_reg_leak
-```hb
-a := @use("math.hb").min(100, 50)
-
-main := fn(): int {
-	return a
-}
-
-// in module: math.hb
-
-SIZEOF_INT := 32
-SHIFT := SIZEOF_INT - 1
-min := fn(a: int, b: int): int {
-	c := a - b
-	return b + (c & c >> SHIFT)
-}
-```
-
-#### different_types
-```hb
-Color := struct {
-	r: u8,
-	g: u8,
-	b: u8,
-	a: u8,
-}
-
-Point := struct {
-	x: u32,
-	y: u32,
-}
-
-Pixel := struct {
-	color: Color,
-	point: Point,
-}
-
-main := fn(): int {
-	pixel := Pixel.{
-		color: Color.{
-			r: 255,
-			g: 0,
-			b: 0,
-			a: 255,
-		},
-		point: Point.{
-			x: 0,
-			y: 2,
-		},
-	}
-
-	soupan := 1
-	if *(&pixel.point.x + soupan) != 2 {
-		return 0
-	}
-
-	if *(&pixel.point.y - 1) != 0 {
-		return 64
-	}
-
-	return pixel.point.x + pixel.point.y + pixel.color.r
-		+ pixel.color.g + pixel.color.b + pixel.color.a
-}
-```
-
-#### struct_return_from_module_function
-```hb
-bar := @use("bar.hb")
-
-main := fn(): int {
-	return 7 - bar.foo().x - bar.foo().y - bar.foo().z
-}
-
-// in module: bar.hb
-
-
-foo := fn(): Foo {
-	return .{x: 3, y: 2, z: 2}
-}
-
-Foo := struct {x: int, y: u32, z: u32}
-```
-
-#### sort_something_viredly
-```hb
-main := fn(): int {
-	foo := sqrt
-	return 0
-}
-
-sqrt := fn(x: int): int {
-	temp := 0
-	g := 0
-	b := 32768
-	bshift := 15
-	loop if b == 0 break else {
-		bshift -= 1
-		temp = b + (g << 1)
-		temp <<= bshift
-		if x >= temp {
-			g += b
-			x -= temp
-		}
-		b >>= 1
-	}
-	return g
-}
-```
-
-#### hex_octal_binary_literals
-```hb
-main := fn(): int {
-	hex := 0xFF
-	decimal := 255
-	octal := 0o377
-	binary := 0b11111111
-
-	if hex == decimal & octal == decimal & binary == decimal {
-		return 0
-	}
-	return 1
-}
-```
-
-#### structs_in_registers
-```hb
-ColorBGRA := struct {b: u8, g: u8, r: u8, a: u8}
-MAGENTA := ColorBGRA.{b: 205, g: 0, r: 205, a: 255}
-
-main := fn(): int {
-	color := MAGENTA
-	return color.r
-}
-```
-
-#### comptime_function_from_another_file
-```hb
-stn := @use("stn.hb")
-
-CONST_A := 100
-CONST_B := 50
-a := stn.math.min(CONST_A, CONST_B)
-
-main := fn(): int {
-	return a
-}
-
-// in module: stn.hb
-math := @use("math.hb")
-
-// in module: math.hb
-SIZEOF_INT := 32
-SHIFT := SIZEOF_INT - 1
-min := fn(a: int, b: int): int {
-	c := a - b
-	return b + (c & c >> SHIFT)
-}
-```
-
-### Just Testing Optimizations
-
-#### const_folding_with_arg
-```hb
-main := fn(arg: int): int {
-	// reduces to 0
-	return arg + 0 - arg * 1 + arg + 1 + arg + 2 + arg + 3 - arg * 3 - 6
-}
-```
-
-#### branch_assignments
-```hb
-main := fn(arg: int): int {
-	if arg == 1 {
-		arg = 1
-	} else if arg == 0 {
-		arg = 2
-	} else {
-		arg = 3
-	}
-	return arg
-}
-```
-
-#### inline_test
-```hb
-Point := struct {x: int, y: int}
-Buffer := struct {}
-Transform := Point
-ColorBGRA := Point
-
-line := fn(buffer: Buffer, p0: Point, p1: Point, color: ColorBGRA, thickness: int): void {
-	if true {
-		if p0.x > p1.x {
-			@inline(line_low, buffer, p1, p0, color)
-		} else {
-			@inline(line_low, buffer, p0, p1, color)
-		}
-	} else {
-		if p0.y > p1.y {
-			// blah, test leading new line on directives
-
-			@inline(line_high, buffer, p1, p0, color)
-		} else {
-			@inline(line_high, buffer, p0, p1, color)
-		}
-	}
-	return
-}
-
-line_low := fn(buffer: Buffer, p0: Point, p1: Point, color: ColorBGRA): void {
-	return
-}
-
-line_high := fn(buffer: Buffer, p0: Point, p1: Point, color: ColorBGRA): void {
-	return
-}
-
-screenidx := @use("screen.hb").screenidx
-
-rect_line := fn(buffer: Buffer, pos: Point, tr: Transform, color: ColorBGRA, thickness: int): void {
-	t := 0
-	y := 0
-	x := 0
-	loop if t == thickness break else {
-		y = pos.y
-		x = pos.x
-		loop if y == pos.y + tr.x break else {
-			a := 1 + @inline(screenidx, 10)
-			a = 1 + @inline(screenidx, 2)
-			y += 1
-		}
-		t += 1
-	}
-	return
-}
-
-random := @use("random.hb")
-
-example := fn(): void {
-	loop {
-		random_x := @inline(random.integer, 0, 1024)
-		random_y := random.integer(0, 768)
-		a := @inline(screenidx, random_x)
-		break
-	}
-	return
-}
-
-main := fn(): int {
-	line(.(), .(0, 0), .(0, 0), .(0, 0), 10)
-	rect_line(.(), .(0, 0), .(0, 0), .(0, 0), 10)
-	example()
-	return 0
-}
-
-// in module: screen.hb
-
-screenidx := fn(orange: int): int {
-	return orange
-}
-
-// in module: random.hb
-
-integer := fn(min: int, max: int): int {
-	rng := @as(int, @eca(3, 4))
-
-	if min != 0 | max != 0 {
-		return rng % (max - min + 1) + min
-	}
-	return rng
-}
-```
-
-#### some_generic_code
-```hb
-some_func := fn($Elem: type): void {
-	return
-}
-
-main := fn(): void {
-	some_func(u8)
-	return
-}
-```
-
-#### integer_inference_issues
-```hb
-.{integer_range} := @use("random.hb")
-main := fn(): void {
-	a := integer_range(0, 1000)
-	return
-}
-
-// in module: random.hb
-integer_range := fn(min: uint, max: int): uint {
-	return @eca(3, 4) % (@bitcast(max) - min + 1) + min
-}
-```
-
-#### exhaustive_loop_testing
-```hb
-main := fn(): int {
-	if multiple_breaks(0) != 3 {
-		return 1
-	}
-
-	if multiple_breaks(4) != 10 {
-		return 2
-	}
-
-	if state_change_in_break(0) != 0 {
-		return 3
-	}
-
-	if state_change_in_break(4) != 10 {
-		return 4
-	}
-
-	if continue_and_state_change(10) != 10 {
-		return 5
-	}
-
-	if continue_and_state_change(3) != 0 {
-		return 6
-	}
-
-	return 0
-}
-
-multiple_breaks := fn(arg: int): int {
-	loop if arg < 10 {
-		arg += 1
-		if arg == 3 break
-	} else break
-	return arg
-}
-
-state_change_in_break := fn(arg: int): int {
-	loop if arg < 10 {
-		if arg == 3 {
-			arg = 0
-			break
-		}
-		arg += 1
-	} else break
-	return arg
-}
-
-continue_and_state_change := fn(arg: int): int {
-	loop if arg < 10 {
-		if arg == 2 {
-			arg = 4
-			continue
-		}
-		if arg == 3 {
-			arg = 0
-			break
-		}
-		arg += 1
-	} else break
-	return arg
-}
-```
-
-#### writing_into_string
-```hb
-outl := fn(): void {
-	msg := "whahaha\0"
-	@as(u8, 0)
-	return
-}
-
-inl := fn(): void {
-	msg := "luhahah\0"
-	return
-}
-
-main := fn(): void {
-	outl()
-	inl()
-	return
-}
-```
-
-#### request_page
-```hb
-request_page := fn(page_count: u8): ^u8 {
-	msg := "\{00}\{01}xxxxxxxx\0"
-	msg_page_count := msg + 1;
-	*msg_page_count = page_count
-	return @eca(3, 2, msg, 12)
-}
-
-create_back_buffer := fn(total_pages: int): ^u32 {
-	if total_pages <= 0xFF {
-		return @bitcast(request_page(total_pages))
-	}
-	ptr := request_page(255)
-	remaining := total_pages - 0xFF
-	loop if remaining <= 0 break else {
-		if remaining < 0xFF {
-			request_page(remaining)
-		} else {
-			request_page(0xFF)
-		}
-		remaining -= 0xFF
-	}
-	return @bitcast(ptr)
-}
-
-main := fn(): void {
-	create_back_buffer(400)
-	return
-}
-```
-
-#### tests_ptr_to_ptr_copy
-```hb
-main := fn(): int {
-	back_buffer := @as([u8; 1024 * 10], idk)
-
-	n := 0
-	loop if n >= 1024 break else {
-		back_buffer[n] = 64
-		n += 1
-	}
-	n = 1
-	loop if n >= 10 break else {
-		*(@as(^[u8; 1024], @bitcast(&back_buffer)) + n) = *@as(^[u8; 1024], @bitcast(&back_buffer))
-		n += 1
-	}
-	return back_buffer[1024 * 2]
-}
-```

hblang/command-help.txt

@@ -1,4 +0,0 @@
---fmt - format all source files
---fmt-current - format mentioned file
-	--fmt-stdout - dont write the formatted file but print it
---threads <1...> - number of threads compiler can use [default: 1]

hblang/src/main.rs

@@ -1,28 +0,0 @@
-use std::num::NonZeroUsize;
-
-fn main() -> std::io::Result<()> {
-    let args = std::env::args().collect::<Vec<_>>();
-    let args = args.iter().map(String::as_str).collect::<Vec<_>>();
-
-    if args.contains(&"--help") || args.contains(&"-h") {
-        println!("Usage: hbc [OPTIONS...] <FILE>");
-        println!(include_str!("../command-help.txt"));
-        return Err(std::io::ErrorKind::Other.into());
-    }
-
-    hblang::run_compiler(
-        args.get(1).copied().unwrap_or("main.hb"),
-        hblang::Options {
-            fmt: args.contains(&"--fmt"),
-            fmt_current: args.contains(&"--fmt-current"),
-            dump_asm: args.contains(&"--dump-asm"),
-            extra_threads: args
-                .iter()
-                .position(|&a| a == "--threads")
-                .map(|i| args[i + 1].parse::<NonZeroUsize>().expect("--threads expects integer"))
-                .map_or(1, NonZeroUsize::get)
-                - 1,
-        },
-        &mut std::io::stdout(),
-    )
-}

hblang/tests/codegen_tests_arithmetic.txt

@@ -1,28 +0,0 @@
-main:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    LI64 r32, 10d
-    LI64 r33, 20d
-    LI64 r34, 2d
-    DIRS64 r33, r0, r33, r34
-    SUB64 r32, r32, r33
-    LI64 r33, 4d
-    LI64 r34, 2d
-    ADDI64 r34, r34, 2d
-    MUL64 r33, r33, r34
-    ADD64 r32, r32, r33
-    LI64 r33, 4d
-    MULI64 r33, r33, 4d
-    SUB64 r32, r32, r33
-    LI64 r33, 1d
-    SLUI64 r33, r33, 0b
-    ADD64 r32, r32, r33
-    LI64 r33, 1d
-    NEG r33, r33
-    ADD64 r1, r32, r33
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-code size: 205
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_arrays.txt

@@ -1,68 +0,0 @@
-main:
-    ADDI64 r254, r254, -68d
-    ST r31, r254, 28a, 40h
-    LI64 r32, 511d
-    LI64 r33, 0d
-    ST r33, r254, 24a, 1h
-    LI64 r33, 0d
-    ST r33, r254, 25a, 1h
-    CP r33, r32
-    ANDI r33, r33, 255d
-    ST r33, r254, 26a, 1h
-    SRUI16 r32, r32, 8b
-    ANDI r32, r32, 255d
-    ST r32, r254, 27a, 1h
-    CP r32, r0
-    LD r32, r254, 24a, 4h
-    ST r32, r254, 0a, 4h
-    ADDI64 r32, r254, 0d
-    LI64 r33, 1d
-    ST r33, r254, 4a, 8h
-    LI64 r33, 2d
-    ST r33, r254, 12a, 8h
-    LI64 r33, 4d
-    ST r33, r254, 20a, 8h
-    ADDI64 r33, r254, 4d
-    CP r2, r33
-    JAL r31, r0, :pass
-    CP r33, r1
-    ADDI64 r34, r254, 0d
-    LI64 r35, 3d
-    ADD64 r34, r34, r35
-    CP r35, r0
-    LD r35, r34, 0a, 1h
-    SXT8 r35, r35
-    ADD64 r1, r33, r35
-    LD r31, r254, 28a, 40h
-    ADDI64 r254, r254, 68d
-    JALA r0, r31, 0a
-pass:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r32, r2
-    CP r33, r32
-    LI64 r34, 0d
-    MULI64 r34, r34, 8d
-    ADD64 r33, r33, r34
-    LD r34, r33, 0a, 8h
-    CP r33, r32
-    LI64 r35, 1d
-    MULI64 r35, r35, 8d
-    ADD64 r33, r33, r35
-    LD r35, r33, 0a, 8h
-    ADD64 r34, r34, r35
-    CP r33, r32
-    LI64 r35, 1d
-    MULI64 r35, r35, 8d
-    ADD64 r32, r32, r35
-    LD r35, r32, 0a, 8h
-    MULI64 r35, r35, 8d
-    ADD64 r33, r33, r35
-    LD r35, r33, 0a, 8h
-    ADD64 r1, r34, r35
-    LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-code size: 580
-ret: 8
-status: Ok(())

hblang/tests/codegen_tests_comments.txt

@@ -1,17 +0,0 @@
-foo:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    JAL r31, r0, :foo
-    LI64 r1, 0d
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 143
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_comptime_function_from_another_file.txt

@@ -1,11 +0,0 @@
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LRA r32, r0, :a
-    LD r1, r32, 0a, 8h
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 95
-ret: 50
-status: Ok(())

hblang/tests/codegen_tests_comptime_min_reg_leak.txt

@@ -1,11 +0,0 @@
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LRA r32, r0, :a
-    LD r1, r32, 0a, 8h
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 218
-ret: 50
-status: Ok(())

hblang/tests/codegen_tests_different_types.txt

@@ -1,57 +0,0 @@
-main:
-    ADDI64 r254, r254, -44d
-    ST r31, r254, 12a, 32h
-    LI64 r32, 255d
-    ST r32, r254, 0a, 1h
-    LI64 r32, 0d
-    ST r32, r254, 1a, 1h
-    LI64 r32, 0d
-    ST r32, r254, 2a, 1h
-    LI64 r32, 255d
-    ST r32, r254, 3a, 1h
-    LI64 r32, 0d
-    ST r32, r254, 4a, 4h
-    LI64 r32, 2d
-    ST r32, r254, 8a, 4h
-    LI64 r32, 1d
-    ADDI64 r33, r254, 4d
-    CP r34, r32
-    MULI64 r34, r34, 4d
-    ADD64 r33, r33, r34
-    CP r32, r0
-    LD r32, r33, 0a, 4h
-    LI64 r34, 2d
-    JEQ r32, r34, :0
-    LI64 r1, 0d
-    JMP :1
- 0: ADDI64 r34, r254, 8d
-    ADDI64 r34, r34, -4d
-    CP r32, r0
-    LD r32, r34, 0a, 4h
-    LI64 r33, 0d
-    JEQ r32, r33, :2
-    LI64 r1, 64d
-    JMP :1
- 2: CP r33, r0
-    LD r33, r254, 4a, 4h
-    CP r32, r0
-    LD r32, r254, 8a, 4h
-    ADD32 r33, r33, r32
-    CP r32, r0
-    LD r32, r254, 0a, 1h
-    ADD32 r33, r33, r32
-    CP r32, r0
-    LD r32, r254, 1a, 1h
-    ADD32 r33, r33, r32
-    CP r32, r0
-    LD r32, r254, 2a, 1h
-    ADD32 r33, r33, r32
-    CP r32, r0
-    LD r32, r254, 3a, 1h
-    ADD32 r1, r33, r32
- 1: LD r31, r254, 12a, 32h
-    ADDI64 r254, r254, 44d
-    JALA r0, r31, 0a
-code size: 474
-ret: 512
-status: Ok(())

hblang/tests/codegen_tests_directives.txt

@@ -1,27 +0,0 @@
-main:
-    ADDI64 r254, r254, -80d
-    ST r31, r254, 16a, 64h
-    LI64 r32, 10d
-    LI64 r33, 30d
-    LI64 r34, 40d
-    LI64 r35, 16d
-    LI64 r36, 8d
-    LI64 r37, 10d
-    LI64 r2, 1d
-    LI64 r38, 10d
-    ST r38, r254, 0a, 8h
-    LI64 r38, 20d
-    ST r38, r254, 8a, 8h
-    LD r3, r254, 0a, 16h
-    LI64 r5, 5d
-    LI64 r6, 6d
-    ECA 
-    CP r38, r1
-    LI64 r1, 0d
-    LD r31, r254, 16a, 64h
-    ADDI64 r254, r254, 80d
-    JALA r0, r31, 0a
-ev: Ecall
-code size: 230
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_fb_driver.txt

@@ -1,74 +0,0 @@
-main:
-    ADDI64 r254, r254, -80d
-    ST r31, r254, 0a, 80h
-    JAL r31, r0, :check_platform
-    CP r32, r1
-    LI64 r33, 100d
-    LI64 r34, 30d
-    LI64 r35, 0d
-    LI64 r36, 0d
- 4: CP r37, r35
-    CP r38, r34
-    ADDI64 r38, r38, 1d
-    CMPS r37, r37, r38
-    CMPUI r37, r37, 1d
-    JEQ r37, r0, :0
-    CP r2, r35
-    CP r3, r36
-    CP r4, r33
-    JAL r31, r0, :set_pixel
-    CP r37, r1
-    CP r38, r35
-    ADDI64 r38, r38, 1d
-    CP r35, r38
-    JMP :1
- 0: CP r2, r35
-    CP r3, r36
-    CP r4, r33
-    JAL r31, r0, :set_pixel
-    CP r38, r1
-    LI64 r35, 0d
-    CP r39, r36
-    ADDI64 r39, r39, 1d
-    CP r36, r39
- 1: CP r39, r36
-    CP r40, r33
-    CMPS r39, r39, r40
-    CMPUI r39, r39, 0d
-    NOT r39, r39
-    JEQ r39, r0, :2
-    JMP :3
- 2: JMP :4
- 3: LI64 r1, 0d
-    LD r31, r254, 0a, 80h
-    ADDI64 r254, r254, 80d
-    JALA r0, r31, 0a
-set_pixel:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    CP r33, r3
-    CP r34, r4
-    MUL64 r33, r33, r34
-    ADD64 r33, r33, r32
-    LI64 r1, 0d
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-check_platform:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    JAL r31, r0, :x86_fb_ptr
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-x86_fb_ptr:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r1, 100d
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 511
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_functions.txt

@@ -1,32 +0,0 @@
-add_one:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    CP r32, r2
-    ADDI64 r1, r32, 1d
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-add_two:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    CP r32, r2
-    ADDI64 r1, r32, 2d
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    LI64 r2, 10d
-    JAL r31, r0, :add_one
-    CP r32, r1
-    LI64 r2, 20d
-    JAL r31, r0, :add_two
-    CP r33, r1
-    ADD64 r1, r32, r33
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-code size: 257
-ret: 33
-status: Ok(())

hblang/tests/codegen_tests_generic_functions.txt

@@ -1,38 +0,0 @@
-add:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r2
-    CP r33, r3
-    ADD64 r1, r32, r33
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-add:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r2
-    CP r33, r3
-    ADD32 r1, r32, r33
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    LI64 r2, 2d
-    LI64 r3, 2d
-    JAL r31, r0, :add
-    CP r32, r1
-    LI64 r2, 1d
-    LI64 r3, 3d
-    JAL r31, r0, :add
-    CP r33, r1
-    CP r34, r32
-    SXT32 r34, r34
-    SUB64 r1, r34, r33
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-code size: 275
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_generic_types.txt

@@ -1,142 +0,0 @@
-deinit:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r2
-    LD r2, r32, 0a, 8h
-    LD r33, r32, 16a, 8h
-    MULI64 r33, r33, 8d
-    CP r3, r33
-    LI64 r4, 8d
-    JAL r31, r0, :free
-    CP r1, r32
-    JAL r31, r0, :new
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-free:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r32, r2
-    CP r33, r3
-    CP r34, r4
-    LRA r35, r0, :FREE_SYS_CALL
-    LD r2, r35, 0a, 8h
-    CP r3, r32
-    CP r4, r33
-    CP r5, r34
-    ECA 
-    LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -48d
-    ST r31, r254, 24a, 24h
-    ADDI64 r1, r254, 0d
-    JAL r31, r0, :new
-    ADDI64 r32, r254, 0d
-    CP r2, r32
-    LI64 r3, 69d
-    JAL r31, r0, :push
-    CP r32, r1
-    LD r32, r254, 0a, 8h
-    LD r33, r32, 0a, 8h
-    ADDI64 r32, r254, 0d
-    CP r2, r32
-    JAL r31, r0, :deinit
-    CP r1, r33
-    LD r31, r254, 24a, 24h
-    ADDI64 r254, r254, 48d
-    JALA r0, r31, 0a
-malloc:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    CP r33, r3
-    LRA r34, r0, :MALLOC_SYS_CALL
-    LD r2, r34, 0a, 8h
-    CP r3, r32
-    CP r4, r33
-    ECA 
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-new:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r1
-    LI64 r33, 0d
-    ST r33, r32, 0a, 8h
-    LI64 r33, 0d
-    ST r33, r32, 8a, 8h
-    LI64 r33, 0d
-    ST r33, r32, 16a, 8h
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-push:
-    ADDI64 r254, r254, -72d
-    ST r31, r254, 0a, 72h
-    CP r32, r2
-    CP r33, r3
-    LD r34, r32, 8a, 8h
-    LD r35, r32, 16a, 8h
-    JNE r34, r35, :0
-    LD r35, r32, 16a, 8h
-    LI64 r34, 0d
-    JNE r35, r34, :1
-    LI64 r34, 1d
-    ST r34, r32, 16a, 8h
-    JMP :2
- 1: LD r34, r32, 16a, 8h
-    MULI64 r34, r34, 2d
-    ST r34, r32, 16a, 8h
- 2: LD r34, r32, 16a, 8h
-    MULI64 r34, r34, 8d
-    CP r2, r34
-    LI64 r3, 8d
-    JAL r31, r0, :malloc
-    CP r34, r1
-    LI64 r35, 0d
-    JNE r34, r35, :3
-    LI64 r1, 0d
-    JMP :4
- 3: LD r35, r32, 0a, 8h
-    CP r36, r34
-    LD r37, r32, 0a, 8h
-    LD r38, r32, 8a, 8h
-    MULI64 r38, r38, 8d
-    ADD64 r37, r37, r38
- 7: JNE r35, r37, :5
-    JMP :6
- 5: CP r38, r36
-    CP r39, r35
-    BMC r39, r38, 8h
-    ADDI64 r35, r35, 8d
-    ADDI64 r36, r36, 8d
-    JMP :7
- 6: LD r38, r32, 8a, 8h
-    LI64 r39, 0d
-    JEQ r38, r39, :8
-    LD r2, r32, 0a, 8h
-    LD r39, r32, 8a, 8h
-    MULI64 r39, r39, 8d
-    CP r3, r39
-    LI64 r4, 8d
-    JAL r31, r0, :free
- 8: ST r34, r32, 0a, 8h
- 0: LD r34, r32, 0a, 8h
-    LD r39, r32, 8a, 8h
-    MULI64 r39, r39, 8d
-    ADD64 r34, r34, r39
-    CP r39, r34
-    ST r33, r39, 0a, 8h
-    LD r39, r32, 8a, 8h
-    ADDI64 r39, r39, 1d
-    ST r39, r32, 8a, 8h
-    CP r1, r34
- 4: LD r31, r254, 0a, 72h
-    ADDI64 r254, r254, 72d
-    JALA r0, r31, 0a
-code size: 1201
-ret: 69
-status: Ok(())

hblang/tests/codegen_tests_global_variables.txt

@@ -1,16 +0,0 @@
-main:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    LRA r32, r0, :complex_global_var
-    LRA r33, r0, :complex_global_var
-    LD r34, r33, 0a, 8h
-    ADDI64 r34, r34, 5d
-    ST r34, r32, 0a, 8h
-    LRA r32, r0, :complex_global_var
-    LD r1, r32, 0a, 8h
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-code size: 146
-ret: 55
-status: Ok(())

hblang/tests/codegen_tests_hex_octal_binary_literals.txt

@@ -1,28 +0,0 @@
-main:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    LI64 r32, 255d
-    LI64 r33, 255d
-    LI64 r34, 255d
-    LI64 r35, 255d
-    CMPS r32, r32, r33
-    CMPUI r32, r32, 0d
-    NOT r32, r32
-    CMPS r34, r34, r33
-    CMPUI r34, r34, 0d
-    NOT r34, r34
-    AND r32, r32, r34
-    CMPS r35, r35, r33
-    CMPUI r35, r35, 0d
-    NOT r35, r35
-    AND r32, r32, r35
-    JEQ r32, r0, :0
-    LI64 r1, 0d
-    JMP :1
- 0: LI64 r1, 1d
- 1: LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-code size: 199
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_idk.txt

@@ -1,25 +0,0 @@
-main:
-    ADDI64 r254, r254, -160d
-    ST r31, r254, 128a, 32h
-    LI64 r32, 0d
- 2: LI64 r33, 128d
-    JLTS r32, r33, :0
-    JMP :1
- 0: ADDI64 r33, r254, 0d
-    CP r34, r32
-    ADD64 r33, r33, r34
-    LI64 r34, 69d
-    ST r34, r33, 0a, 1h
-    ADDI64 r32, r32, 1d
-    JMP :2
- 1: ADDI64 r33, r254, 0d
-    LI64 r34, 42d
-    ADD64 r33, r33, r34
-    CP r1, r0
-    LD r1, r33, 0a, 1h
-    LD r31, r254, 128a, 32h
-    ADDI64 r254, r254, 160d
-    JALA r0, r31, 0a
-code size: 195
-ret: 69
-status: Ok(())

hblang/tests/codegen_tests_if_statements.txt

@@ -1,32 +0,0 @@
-fib:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r2
-    LI64 r33, 2d
-    JGTS r32, r33, :0
-    LI64 r1, 1d
-    JMP :1
- 0: CP r33, r32
-    ADDI64 r33, r33, -1d
-    CP r2, r33
-    JAL r31, r0, :fib
-    CP r33, r1
-    ADDI64 r32, r32, -2d
-    CP r2, r32
-    JAL r31, r0, :fib
-    CP r32, r1
-    ADD64 r1, r33, r32
- 1: LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r2, 10d
-    JAL r31, r0, :fib
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 231
-ret: 55
-status: Ok(())

hblang/tests/codegen_tests_inline.txt

@@ -1,13 +0,0 @@
-main:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    LI64 r33, 1d
-    ADDI64 r33, r33, 2d
-    ADDI64 r32, r33, 3d
-    ADDI64 r1, r32, -6d
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-code size: 110
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_inline_test.txt

@@ -1,161 +0,0 @@
-example:
-    ADDI64 r254, r254, -48d
-    ST r31, r254, 0a, 48h
-    LI64 r2, 3d
-    LI64 r3, 4d
-    ECA 
-    CP r33, r1
-    LI64 r34, 0d
-    LI64 r35, 0d
-    CMPS r34, r34, r35
-    CMPUI r34, r34, 0d
-    LI64 r35, 1024d
-    LI64 r36, 0d
-    CMPS r35, r35, r36
-    CMPUI r35, r35, 0d
-    OR r34, r34, r35
-    JEQ r34, r0, :0
-    CP r34, r33
-    LI64 r35, 1024d
-    ADDI64 r35, r35, 0d
-    ADDI64 r35, r35, 1d
-    DIRS64 r0, r34, r34, r35
-    ADDI64 r32, r34, 0d
-    JMP :1
- 0: CP r32, r33
- 1: LI64 r2, 0d
-    LI64 r3, 768d
-    JAL r31, r0, :integer
-    CP r33, r1
-    CP r34, r32
-    JMP :2
- 2: LD r31, r254, 0a, 48h
-    ADDI64 r254, r254, 48d
-    JALA r0, r31, 0a
-integer:
-    ADDI64 r254, r254, -56d
-    ST r31, r254, 0a, 56h
-    CP r32, r2
-    CP r33, r3
-    LI64 r2, 3d
-    LI64 r3, 4d
-    ECA 
-    CP r34, r1
-    CP r35, r32
-    LI64 r36, 0d
-    CMPS r35, r35, r36
-    CMPUI r35, r35, 0d
-    CP r36, r33
-    LI64 r37, 0d
-    CMPS r36, r36, r37
-    CMPUI r36, r36, 0d
-    OR r35, r35, r36
-    JEQ r35, r0, :0
-    CP r35, r34
-    SUB64 r33, r33, r32
-    ADDI64 r33, r33, 1d
-    DIRS64 r0, r35, r35, r33
-    ADD64 r1, r35, r32
-    JMP :1
- 0: CP r1, r34
- 1: LD r31, r254, 0a, 56h
-    ADDI64 r254, r254, 56d
-    JALA r0, r31, 0a
-line:
-    ADDI64 r254, r254, -80d
-    ST r31, r254, 48a, 32h
-    ST r2, r254, 16a, 16h
-    ST r4, r254, 0a, 16h
-    ST r6, r254, 32a, 16h
-    CP r32, r8
-    LI64 r33, 1d
-    JEQ r33, r0, :0
-    LD r33, r254, 16a, 8h
-    LD r34, r254, 0a, 8h
-    JGTS r33, r34, :1
-    JMP :1
- 1: JMP :2
- 0: LD r34, r254, 24a, 8h
-    LD r33, r254, 8a, 8h
-    JGTS r34, r33, :2
-    JMP :2
- 2: LD r31, r254, 48a, 32h
-    ADDI64 r254, r254, 80d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -64d
-    ST r31, r254, 48a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 0a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 8a, 8h
-    LD r2, r254, 0a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 16a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 24a, 8h
-    LD r4, r254, 16a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 32a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 40a, 8h
-    LD r6, r254, 32a, 16h
-    LI64 r8, 10d
-    JAL r31, r0, :line
-    LI64 r32, 0d
-    ST r32, r254, 0a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 8a, 8h
-    LD r2, r254, 0a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 16a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 24a, 8h
-    LD r4, r254, 16a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 32a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 40a, 8h
-    LD r6, r254, 32a, 16h
-    LI64 r8, 10d
-    JAL r31, r0, :rect_line
-    JAL r31, r0, :example
-    LI64 r1, 0d
-    LD r31, r254, 48a, 16h
-    ADDI64 r254, r254, 64d
-    JALA r0, r31, 0a
-rect_line:
-    ADDI64 r254, r254, -112d
-    ST r31, r254, 48a, 64h
-    ST r2, r254, 0a, 16h
-    ST r4, r254, 16a, 16h
-    ST r6, r254, 32a, 16h
-    CP r32, r8
-    LI64 r33, 0d
-    LI64 r34, 0d
-    LI64 r35, 0d
- 5: JNE r33, r32, :0
-    JMP :1
- 0: LD r34, r254, 8a, 8h
-    LD r35, r254, 0a, 8h
- 4: LD r36, r254, 8a, 8h
-    LD r37, r254, 16a, 8h
-    ADD64 r36, r36, r37
-    JNE r34, r36, :2
-    JMP :3
- 2: LI64 r36, 1d
-    LI64 r37, 10d
-    ADD64 r36, r36, r37
-    LI64 r37, 1d
-    LI64 r38, 2d
-    ADD64 r36, r37, r38
-    ADDI64 r34, r34, 1d
-    JMP :4
- 3: ADDI64 r33, r33, 1d
-    JMP :5
- 1: LD r31, r254, 48a, 64h
-    ADDI64 r254, r254, 112d
-    JALA r0, r31, 0a
-code size: 1400
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_integer_inference_issues.txt

@@ -1,29 +0,0 @@
-integer_range:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    CP r33, r3
-    LI64 r2, 3d
-    LI64 r3, 4d
-    ECA 
-    CP r34, r1
-    SUB64 r33, r33, r32
-    ADDI64 r33, r33, 1d
-    DIRU64 r0, r34, r34, r33
-    ADD64 r1, r34, r32
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LI64 r2, 0d
-    LI64 r3, 1000d
-    JAL r31, r0, :integer_range
-    CP r32, r1
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 210
-ret: 42
-status: Ok(())

hblang/tests/codegen_tests_loops.txt

@@ -1,30 +0,0 @@
-fib:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r32, r2
-    LI64 r33, 0d
-    LI64 r34, 1d
- 2: LI64 r35, 0d
-    JNE r32, r35, :0
-    JMP :1
- 0: CP r35, r33
-    ADD64 r35, r35, r34
-    CP r33, r34
-    CP r34, r35
-    ADDI64 r32, r32, -1d
-    JMP :2
- 1: CP r1, r33
-    LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r2, 10d
-    JAL r31, r0, :fib
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 218
-ret: 55
-status: Ok(())

hblang/tests/codegen_tests_pointers.txt

@@ -1,35 +0,0 @@
-drop:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    CP r32, r2
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 8a, 32h
-    LI64 r32, 1d
-    ST r32, r254, 0a, 8h
-    ADDI64 r32, r254, 0d
-    CP r2, r32
-    JAL r31, r0, :modify
-    LD r2, r254, 0a, 8h
-    JAL r31, r0, :drop
-    LI64 r33, 0d
-    LD r34, r32, 0a, 8h
-    ADDI64 r1, r34, -2d
-    LD r31, r254, 8a, 32h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-modify:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r32, r2
-    LI64 r33, 2d
-    ST r33, r32, 0a, 8h
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-code size: 312
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_request_page.txt

@@ -1,59 +0,0 @@
-create_back_buffer:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    LI64 r33, 255d
-    JGTS r32, r33, :0
-    CP r2, r32
-    JAL r31, r0, :request_page
-    JMP :1
- 0: LI64 r2, 255d
-    JAL r31, r0, :request_page
-    CP r33, r1
-    ADDI64 r32, r32, -255d
- 6: LI64 r34, 0d
-    JGTS r32, r34, :2
-    JMP :3
- 2: LI64 r34, 255d
-    JLTS r32, r34, :4
-    LI64 r2, 255d
-    JAL r31, r0, :request_page
-    CP r34, r1
-    JMP :5
- 4: CP r2, r32
-    JAL r31, r0, :request_page
-    CP r34, r1
- 5: ADDI64 r32, r32, -255d
-    JMP :6
- 3: CP r1, r33
- 1: LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LI64 r2, 400d
-    JAL r31, r0, :create_back_buffer
-    CP r32, r1
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-request_page:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    LRA r33, r0, :"\0\u{1}xxxxxxxx\0"
-    CP r34, r33
-    ADDI64 r34, r34, 1d
-    ST r32, r34, 0a, 1h
-    LI64 r2, 3d
-    LI64 r3, 2d
-    CP r4, r33
-    LI64 r5, 12d
-    ECA 
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-code size: 443
-ret: 42
-status: Ok(())

hblang/tests/codegen_tests_some_generic_code.txt

@@ -1,16 +0,0 @@
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    JAL r31, r0, :some_func
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-some_func:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 133
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_sort_something_viredly.txt

@@ -1,11 +0,0 @@
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LI64 r32, 1610612737d
-    LI64 r1, 0d
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 87
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_struct_operators.txt

@@ -1,75 +0,0 @@
-main:
-    ADDI64 r254, r254, -136d
-    ST r31, r254, 112a, 24h
-    LI64 r32, 1d
-    ST r32, r254, 32a, 8h
-    LI64 r32, 2d
-    ST r32, r254, 40a, 8h
-    LI64 r32, 3d
-    ST r32, r254, 16a, 8h
-    LI64 r32, 4d
-    ST r32, r254, 24a, 8h
-    LD r32, r254, 32a, 8h
-    LD r33, r254, 16a, 8h
-    ADD64 r32, r32, r33
-    ST r32, r254, 48a, 8h
-    LD r32, r254, 40a, 8h
-    LD r33, r254, 24a, 8h
-    ADD64 r32, r32, r33
-    ST r32, r254, 56a, 8h
-    LD r32, r254, 16a, 8h
-    LD r33, r254, 32a, 8h
-    SUB64 r32, r32, r33
-    ST r32, r254, 64a, 8h
-    LD r32, r254, 24a, 8h
-    LD r33, r254, 40a, 8h
-    SUB64 r32, r32, r33
-    ST r32, r254, 72a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 0a, 8h
-    LI64 r32, 0d
-    ST r32, r254, 8a, 8h
-    LD r32, r254, 0a, 8h
-    LD r33, r254, 16a, 8h
-    SUB64 r32, r32, r33
-    ST r32, r254, 80a, 8h
-    LD r32, r254, 8a, 8h
-    LD r33, r254, 24a, 8h
-    SUB64 r32, r32, r33
-    ST r32, r254, 88a, 8h
-    ADDI64 r32, r254, 32d
-    ADDI64 r33, r254, 96d
-    BMC r32, r33, 16h
-    LD r33, r254, 80a, 8h
-    LD r32, r254, 48a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 80a, 8h
-    LD r33, r254, 88a, 8h
-    LD r32, r254, 56a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 88a, 8h
-    LD r33, r254, 96a, 8h
-    LD r32, r254, 64a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 96a, 8h
-    LD r33, r254, 104a, 8h
-    LD r32, r254, 72a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 104a, 8h
-    LD r33, r254, 80a, 8h
-    LD r32, r254, 96a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 96a, 8h
-    LD r33, r254, 88a, 8h
-    LD r32, r254, 104a, 8h
-    ADD64 r33, r33, r32
-    ST r33, r254, 104a, 8h
-    LD r33, r254, 96a, 8h
-    LD r32, r254, 104a, 8h
-    ADD64 r1, r33, r32
-    LD r31, r254, 112a, 24h
-    ADDI64 r254, r254, 136d
-    JALA r0, r31, 0a
-code size: 778
-ret: 10
-status: Ok(())

hblang/tests/codegen_tests_struct_patterns.txt

@@ -1,65 +0,0 @@
-fib:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    LI64 r33, 2d
-    JLTS r32, r33, :0
-    CP r33, r32
-    ADDI64 r33, r33, -1d
-    CP r2, r33
-    JAL r31, r0, :fib
-    CP r33, r1
-    CP r34, r32
-    ADDI64 r34, r34, -2d
-    CP r2, r34
-    JAL r31, r0, :fib
-    CP r34, r1
-    ADD64 r1, r33, r34
-    JMP :1
- 0: CP r1, r32
- 1: LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-fib_iter:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r32, r2
-    LI64 r33, 0d
-    LI64 r34, 1d
- 2: LI64 r35, 0d
-    JNE r32, r35, :0
-    JMP :1
- 0: CP r35, r33
-    ADD64 r35, r35, r34
-    CP r33, r34
-    CP r34, r35
-    ADDI64 r32, r32, -1d
-    JMP :2
- 1: CP r1, r33
-    LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -26d
-    ST r31, r254, 2a, 24h
-    LI64 r32, 10d
-    ST r32, r254, 0a, 1h
-    LI64 r32, 10d
-    ST r32, r254, 1a, 1h
-    CP r32, r0
-    LD r32, r254, 0a, 1h
-    CP r33, r0
-    LD r33, r254, 1a, 1h
-    CP r2, r32
-    JAL r31, r0, :fib
-    CP r32, r1
-    CP r2, r33
-    JAL r31, r0, :fib_iter
-    CP r33, r1
-    SUB64 r1, r32, r33
-    LD r31, r254, 2a, 24h
-    ADDI64 r254, r254, 26d
-    JALA r0, r31, 0a
-code size: 452
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_struct_return_from_module_function.txt

@@ -1,39 +0,0 @@
-foo:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 16a, 16h
-    LI64 r32, 3d
-    ST r32, r254, 0a, 8h
-    LI64 r32, 2d
-    ST r32, r254, 8a, 4h
-    LI64 r32, 2d
-    ST r32, r254, 12a, 4h
-    LD r1, r254, 0a, 16h
-    LD r31, r254, 16a, 16h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 16a, 24h
-    LI64 r32, 7d
-    JAL r31, r0, :foo
-    ST r1, r254, 0a, 16h
-    LD r33, r254, 0a, 8h
-    SUB64 r32, r32, r33
-    JAL r31, r0, :foo
-    ST r1, r254, 0a, 16h
-    CP r33, r0
-    LD r33, r254, 8a, 4h
-    SXT32 r33, r33
-    SUB64 r32, r32, r33
-    JAL r31, r0, :foo
-    ST r1, r254, 0a, 16h
-    CP r33, r0
-    LD r33, r254, 12a, 4h
-    SXT32 r33, r33
-    SUB64 r1, r32, r33
-    LD r31, r254, 16a, 24h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-code size: 341
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_structs.txt

@@ -1,46 +0,0 @@
-main:
-    ADDI64 r254, r254, -48d
-    ST r31, r254, 24a, 24h
-    LI64 r32, 4d
-    ST r32, r254, 0a, 8h
-    LI64 r32, 1d
-    ST r32, r254, 8a, 8h
-    LI64 r32, 3d
-    ST r32, r254, 16a, 8h
-    ADDI64 r2, r254, 0d
-    ADDI64 r1, r254, 0d
-    JAL r31, r0, :odher_pass
-    LD r32, r254, 16a, 8h
-    LI64 r33, 3d
-    JNE r32, r33, :0
-    ADDI64 r33, r254, 0d
-    CP r2, r33
-    JAL r31, r0, :pass
-    JMP :1
- 0: LI64 r1, 0d
- 1: LD r31, r254, 24a, 24h
-    ADDI64 r254, r254, 48d
-    JALA r0, r31, 0a
-odher_pass:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    CP r33, r1
-    CP r34, r33
-    BMC r32, r34, 24h
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-pass:
-    ADDI64 r254, r254, -32d
-    ST r31, r254, 0a, 32h
-    CP r32, r2
-    LD r33, r32, 0a, 8h
-    LD r34, r32, 8a, 8h
-    SUB64 r1, r33, r34
-    LD r31, r254, 0a, 32h
-    ADDI64 r254, r254, 32d
-    JALA r0, r31, 0a
-code size: 394
-ret: 3
-status: Ok(())

hblang/tests/codegen_tests_tests_ptr_to_ptr_copy.txt

@@ -1,38 +0,0 @@
-main:
-    ADDI64 r254, r254, -10272d
-    ST r31, r254, 10240a, 32h
-    LI64 r32, 0d
- 2: LI64 r33, 1024d
-    JLTS r32, r33, :0
-    JMP :1
- 0: ADDI64 r33, r254, 0d
-    CP r34, r32
-    ADD64 r33, r33, r34
-    LI64 r34, 64d
-    ST r34, r33, 0a, 1h
-    ADDI64 r32, r32, 1d
-    JMP :2
- 1: LI64 r32, 1d
- 5: LI64 r33, 10d
-    JLTS r32, r33, :3
-    JMP :4
- 3: ADDI64 r33, r254, 0d
-    CP r34, r32
-    MULI64 r34, r34, 1024d
-    ADD64 r33, r33, r34
-    ADDI64 r34, r254, 0d
-    BMC r34, r33, 1024h
-    ADDI64 r32, r32, 1d
-    JMP :5
- 4: LI64 r33, 1024d
-    MULI64 r33, r33, 2d
-    ADDI64 r34, r254, 0d
-    ADD64 r34, r34, r33
-    CP r1, r0
-    LD r1, r34, 0a, 1h
-    LD r31, r254, 10240a, 32h
-    ADDI64 r254, r254, 10272d
-    JALA r0, r31, 0a
-code size: 297
-ret: 64
-status: Ok(())

hblang/tests/codegen_tests_variables.txt

@@ -1,13 +0,0 @@
-main:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    LI64 r32, 1d
-    LI64 r33, 2d
-    ADDI64 r32, r32, 1d
-    SUB64 r1, r32, r33
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-code size: 102
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_wide_ret.txt

@@ -1,45 +0,0 @@
-main:
-    ADDI64 r254, r254, -48d
-    ST r31, r254, 16a, 32h
-    CP r32, r3
-    CP r33, r4
-    JAL r31, r0, :small_struct
-    CP r34, r1
-    LI64 r34, 0d
-    ST r34, r254, 8a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 9a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 10a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 11a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 12a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 13a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 14a, 1h
-    LI64 r34, 0d
-    ST r34, r254, 15a, 1h
-    LD r34, r254, 8a, 8h
-    ST r34, r254, 0a, 8h
-    ST r34, r254, 8a, 8h
-    LD r1, r254, 0a, 16h
-    LD r31, r254, 16a, 32h
-    ADDI64 r254, r254, 48d
-    JALA r0, r31, 0a
-small_struct:
-    ADDI64 r254, r254, -20d
-    ST r31, r254, 4a, 16h
-    LI64 r32, 0d
-    ST r32, r254, 0a, 2h
-    LI64 r32, 0d
-    ST r32, r254, 2a, 2h
-    CP r1, r0
-    LD r1, r254, 0a, 4h
-    LD r31, r254, 4a, 16h
-    ADDI64 r254, r254, 20d
-    JALA r0, r31, 0a
-code size: 440
-ret: 0
-status: Ok(())

hblang/tests/codegen_tests_writing_into_string.txt

@@ -1,25 +0,0 @@
-inl:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LRA r32, r0, :"luhahah\0"
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    JAL r31, r0, :outl
-    JAL r31, r0, :inl
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-outl:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LRA r32, r0, :"whahaha\0"
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 229
-ret: 0
-status: Ok(())

hblang/tests/son_tests_branch_assignments.txt

@@ -1,17 +0,0 @@
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    LI64 r1, 1d
-    JNE r2, r1, :0
-    JMP :1
- 0: LI64 r32, 0d
-    JNE r2, r32, :2
-    LI64 r1, 2d
-    JMP :1
- 2: LI64 r1, 3d
- 1: LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-code size: 127
-ret: 2
-status: Ok(())

hblang/tests/son_tests_comments.txt

@@ -1,18 +0,0 @@
-main:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    JAL r31, r0, :foo
-    CP r32, r1
-    LI64 r1, 0d
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-foo:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 146
-ret: 0
-status: Ok(())

hblang/tests/son_tests_exhaustive_loop_testing.txt

@@ -1,103 +0,0 @@
-main:
-    ADDI64 r254, r254, -88d
-    ST r31, r254, 0a, 88h
-    LI64 r32, 0d
-    CP r2, r32
-    JAL r31, r0, :multiple_breaks
-    CP r33, r1
-    LI64 r34, 3d
-    JEQ r33, r34, :0
-    LI64 r1, 1d
-    JMP :1
- 0: LI64 r35, 4d
-    CP r2, r35
-    JAL r31, r0, :multiple_breaks
-    CP r36, r1
-    LI64 r37, 10d
-    JEQ r36, r37, :2
-    LI64 r1, 2d
-    JMP :1
- 2: CP r2, r32
-    JAL r31, r0, :state_change_in_break
-    CP r38, r1
-    JEQ r38, r32, :3
-    CP r1, r34
-    JMP :1
- 3: CP r2, r35
-    JAL r31, r0, :state_change_in_break
-    CP r39, r1
-    JEQ r39, r37, :4
-    CP r1, r35
-    JMP :1
- 4: CP r2, r37
-    JAL r31, r0, :continue_and_state_change
-    CP r40, r1
-    JEQ r40, r37, :5
-    LI64 r1, 5d
-    JMP :1
- 5: CP r2, r34
-    JAL r31, r0, :continue_and_state_change
-    CP r41, r1
-    JEQ r41, r32, :6
-    LI64 r1, 6d
-    JMP :1
- 6: CP r1, r32
- 1: LD r31, r254, 0a, 88h
-    ADDI64 r254, r254, 88d
-    JALA r0, r31, 0a
-continue_and_state_change:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r1, r2
-    LI64 r32, 3d
-    LI64 r33, 4d
-    LI64 r34, 2d
-    LI64 r35, 10d
- 6: JLTU r1, r35, :0
-    JMP :1
- 0: JNE r1, r34, :2
-    CP r1, r33
-    JMP :3
- 2: JNE r1, r32, :4
-    LI64 r1, 0d
- 1: JMP :5
- 4: ADDI64 r33, r1, 1d
-    CP r1, r33
- 3: JMP :6
- 5: LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-state_change_in_break:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r1, r2
-    LI64 r32, 3d
-    LI64 r33, 10d
- 4: JLTU r1, r33, :0
-    JMP :1
- 0: JNE r1, r32, :2
-    LI64 r1, 0d
- 1: JMP :3
- 2: ADDI64 r1, r1, 1d
-    JMP :4
- 3: LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-multiple_breaks:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    CP r1, r2
-    LI64 r32, 3d
-    LI64 r33, 10d
- 4: JLTU r1, r33, :0
-    JMP :1
- 0: ADDI64 r1, r1, 1d
-    JNE r1, r32, :2
- 1: JMP :3
- 2: JMP :4
- 3: LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-code size: 704
-ret: 0
-status: Ok(())

hblang/tests/son_tests_fb_driver.txt

@@ -1,60 +0,0 @@
-main:
-    ADDI64 r254, r254, -88d
-    ST r31, r254, 0a, 88h
-    JAL r31, r0, :check_platform
-    CP r32, r1
-    LI64 r33, 0d
-    LI64 r34, 30d
-    LI64 r35, 100d
-    CP r36, r33
-    CP r37, r33
-    CP r38, r33
- 5: JLTU r37, r34, :0
-    ADDI64 r36, r36, 1d
-    CP r2, r33
-    CP r3, r36
-    CP r4, r34
-    JAL r31, r0, :set_pixel
-    CP r39, r1
-    JEQ r39, r38, :1
-    CP r1, r33
-    JMP :2
- 1: JNE r36, r35, :3
-    CP r1, r38
-    JMP :2
- 3: CP r37, r33
-    CP r40, r38
-    JMP :4
- 0: ADDI64 r40, r38, 1d
-    ADDI64 r41, r37, 1d
-    CP r37, r41
- 4: CP r38, r40
-    JMP :5
- 2: LD r31, r254, 0a, 88h
-    ADDI64 r254, r254, 88d
-    JALA r0, r31, 0a
-set_pixel:
-    ADDI64 r254, r254, -16d
-    ST r31, r254, 0a, 16h
-    MUL64 r32, r4, r3
-    ADD64 r1, r32, r2
-    LD r31, r254, 0a, 16h
-    ADDI64 r254, r254, 16d
-    JALA r0, r31, 0a
-check_platform:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    JAL r31, r0, :x86_fb_ptr
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-x86_fb_ptr:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r1, 100d
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 423
-ret: 3000
-status: Ok(())

hblang/tests/son_tests_functions.txt

@@ -1,30 +0,0 @@
-main:
-    ADDI64 r254, r254, -24d
-    ST r31, r254, 0a, 24h
-    LI64 r2, 10d
-    JAL r31, r0, :add_one
-    CP r32, r1
-    LI64 r2, 20d
-    JAL r31, r0, :add_two
-    CP r33, r1
-    ADD64 r1, r33, r32
-    LD r31, r254, 0a, 24h
-    ADDI64 r254, r254, 24d
-    JALA r0, r31, 0a
-add_two:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    ADDI64 r1, r2, 2d
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-add_one:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    ADDI64 r1, r2, 1d
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-code size: 251
-ret: 33
-status: Ok(())

hblang/tests/son_tests_if_statements.txt

@@ -1,29 +0,0 @@
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r2, 10d
-    JAL r31, r0, :fib
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-fib:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    CP r32, r2
-    LI64 r1, 1d
-    LI64 r33, 2d
-    JGTU r32, r33, :0
-    JMP :1
- 0: SUB64 r2, r32, r1
-    JAL r31, r0, :fib
-    CP r34, r1
-    SUB64 r2, r32, r33
-    JAL r31, r0, :fib
-    CP r35, r1
-    ADD64 r1, r35, r34
- 1: LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-code size: 208
-ret: 55
-status: Ok(())

hblang/tests/son_tests_loops.txt

@@ -1,28 +0,0 @@
-main:
-    ADDI64 r254, r254, -8d
-    ST r31, r254, 0a, 8h
-    LI64 r2, 10d
-    JAL r31, r0, :fib
-    LD r31, r254, 0a, 8h
-    ADDI64 r254, r254, 8d
-    JALA r0, r31, 0a
-fib:
-    ADDI64 r254, r254, -40d
-    ST r31, r254, 0a, 40h
-    LI64 r32, 1d
-    LI64 r33, 0d
-    CP r1, r33
-    CP r34, r32
- 2: JNE r2, r33, :0
-    JMP :1
- 0: ADD64 r35, r34, r1
-    SUB64 r2, r2, r32
-    CP r1, r34
-    CP r34, r35
-    JMP :2
- 1: LD r31, r254, 0a, 40h
-    ADDI64 r254, r254, 40d
-    JALA r0, r31, 0a
-code size: 198
-ret: 55
-status: Ok(())

hblang/text-prj/main.hb

@@ -1,11 +0,0 @@
-foo := 0;
-
-.{global, fib, Structa, create_window, WindowID} := @use("pkg.hb")
-
-main := fn(a: int): int {
-	g := global
-
-	win := create_window()
-
-	return fib(g + Structa.(0, 0).foo)
-}

hblang/text-prj/pkg.hb

@@ -1,19 +0,0 @@
-global := 10
-
-Structa := struct {
-	foo: int,
-	goo: int,
-}
-
-create_window := fn(): WindowID {
-    return WindowID.(1, 2)
-}
-
-WindowID := struct {
-    host_id: int,
-    window_id: int,
-}
-
-fib := fn(n: int): int {
-	return n + 1
-}

lang/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "hblang"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "fuzz"
+path = "src/fuzz_main.rs"
+
+[dependencies]
+hbbytecode = { workspace = true, features = ["disasm"] }
+hbvm = { workspace = true, features = ["nightly", "alloc"] }
+hashbrown = { version = "0.15.0", default-features = false, features = ["raw-entry"] }
+log = "0.4.22"
+
+[features]
+default = ["std"]
+std = []
+no_log = ["log/max_level_off"]

lang/build.rs

@@ -0,0 +1,35 @@
+use std::{fmt::Write, iter};
+
+fn main() {
+    const TEST_FILE: &str = "src/testcases.rs";
+    const INPUT: &str = include_str!("./README.md");
+
+    let mut out = String::new();
+    for (name, code) in block_iter(INPUT) {
+        let name = name.replace(' ', "_");
+        _ = writeln!(
+            out,
+            "#[test] fn {name}() {{ run_codegen_test(\"{name}\", r##\"{code}\"##) }}"
+        );
+    }
+
+    std::fs::write(TEST_FILE, out).unwrap();
+}
+
+fn block_iter(mut input: &str) -> impl Iterator<Item = (&str, &str)> {
+    const CASE_PREFIX: &str = "#### ";
+    const CASE_SUFFIX: &str = "\n```hb";
+
+    iter::from_fn(move || loop {
+        let pos = input.find(CASE_PREFIX)?;
+        input = unsafe { input.get_unchecked(pos + CASE_PREFIX.len()..) };
+        let Some((test_name, rest)) = input.split_once(CASE_SUFFIX) else { continue };
+        if !test_name.chars().all(|c| c.is_alphanumeric() || c == '_') {
+            continue;
+        }
+        input = rest;
+        let (body, rest) = input.split_once("```").unwrap_or((input, ""));
+        input = rest;
+        break Some((test_name, body));
+    })
+}

lang/src/backend/hbvm.rs

@@ -0,0 +1,916 @@
+use {
+    super::{AssemblySpec, Backend},
+    crate::{
+        lexer::TokenKind,
+        nodes::{Kind, Nid, Nodes, MEM},
+        parser,
+        ty::{self, Loc, Module, Offset, Size, Types},
+        utils::{EntSlice, EntVec},
+    },
+    alloc::{boxed::Box, collections::BTreeMap, string::String, vec::Vec},
+    core::{assert_matches::debug_assert_matches, error, mem, ops::Range},
+    hbbytecode::{self as instrs, *},
+    reg::Reg,
+    std::borrow::ToOwned,
+};
+
+mod regalloc;
+
+mod reg {
+    pub const STACK_PTR: Reg = 254;
+    pub const ZERO: Reg = 0;
+    pub const RET: Reg = 1;
+    pub const RET_ADDR: Reg = 31;
+
+    pub type Reg = u8;
+}
+
+fn write_reloc(doce: &mut [u8], offset: usize, value: i64, size: u16) {
+    let value = value.to_ne_bytes();
+    doce[offset..offset + size as usize].copy_from_slice(&value[..size as usize]);
+}
+
+#[derive(Clone, Copy)]
+struct TypedReloc {
+    target: ty::Id,
+    reloc: Reloc,
+}
+
+// TODO: make into bit struct (width: u2, sub_offset: u3, offset: u27)
+#[derive(Clone, Copy, Debug)]
+struct Reloc {
+    offset: Offset,
+    sub_offset: u8,
+    width: u8,
+}
+
+impl Reloc {
+    fn new(offset: usize, sub_offset: u8, width: u8) -> Self {
+        Self { offset: offset as u32, sub_offset, width }
+    }
+
+    fn apply_jump(mut self, code: &mut [u8], to: u32, from: u32) -> i64 {
+        self.offset += from;
+        let offset = to as i64 - self.offset as i64;
+        self.write_offset(code, offset);
+        offset
+    }
+
+    fn write_offset(&self, code: &mut [u8], offset: i64) {
+        let bytes = offset.to_ne_bytes();
+        let slice = &mut code[self.offset as usize + self.sub_offset as usize..];
+        slice[..self.width as usize].copy_from_slice(&bytes[..self.width as usize]);
+    }
+}
+
+struct FuncDt {
+    offset: Offset,
+    // TODO: change to indices into common vec
+    relocs: Vec<TypedReloc>,
+    code: Vec<u8>,
+}
+
+impl Default for FuncDt {
+    fn default() -> Self {
+        Self { offset: u32::MAX, relocs: Default::default(), code: Default::default() }
+    }
+}
+
+struct GlobalDt {
+    offset: Offset,
+}
+
+impl Default for GlobalDt {
+    fn default() -> Self {
+        Self { offset: u32::MAX }
+    }
+}
+
+#[derive(Default)]
+struct Assembler {
+    frontier: Vec<ty::Id>,
+    globals: Vec<ty::Global>,
+    funcs: Vec<ty::Func>,
+}
+
+#[derive(Default)]
+pub struct HbvmBackend {
+    funcs: EntVec<ty::Func, FuncDt>,
+    globals: EntVec<ty::Global, GlobalDt>,
+    asm: Assembler,
+    ralloc: regalloc::Res,
+
+    ret_relocs: Vec<Reloc>,
+    relocs: Vec<TypedReloc>,
+    jump_relocs: Vec<(Nid, Reloc)>,
+    code: Vec<u8>,
+    offsets: Vec<Offset>,
+}
+
+pub const TARGET_TRIPLE: &str = "unknown-virt-unknown";
+
+impl HbvmBackend {
+    fn emit(&mut self, instr: (usize, [u8; instrs::MAX_SIZE])) {
+        emit(&mut self.code, instr);
+    }
+}
+
+impl Backend for HbvmBackend {
+    fn triple(&self) -> String {
+        TARGET_TRIPLE.to_owned()
+    }
+
+    fn assemble_bin(
+        &mut self,
+        entry: ty::Func,
+        types: &Types,
+        files: &EntSlice<Module, parser::Ast>,
+        to: &mut Vec<u8>,
+    ) {
+        to.extend([0u8; HEADER_SIZE]);
+
+        binary_prelude(to);
+        let AssemblySpec { code_length, data_length, entry } =
+            self.assemble_reachable(entry, types, files, to);
+
+        let exe = AbleOsExecutableHeader {
+            magic_number: [0x15, 0x91, 0xD2],
+            executable_version: 0,
+            code_length,
+            data_length,
+            debug_length: 0,
+            config_length: 0,
+            metadata_length: 0,
+        };
+        Reloc::new(HEADER_SIZE, 3, 4).apply_jump(to, entry, 0);
+
+        unsafe { *to.as_mut_ptr().cast::<AbleOsExecutableHeader>() = exe }
+    }
+
+    fn assemble_reachable(
+        &mut self,
+        from: ty::Func,
+        types: &Types,
+        _files: &EntSlice<Module, parser::Ast>,
+        to: &mut Vec<u8>,
+    ) -> AssemblySpec {
+        debug_assert!(self.asm.frontier.is_empty());
+        debug_assert!(self.asm.funcs.is_empty());
+        debug_assert!(self.asm.globals.is_empty());
+
+        self.globals.shadow(types.ins.globals.len());
+
+        self.asm.frontier.push(from.into());
+        while let Some(itm) = self.asm.frontier.pop() {
+            match itm.expand() {
+                ty::Kind::Func(func) => {
+                    let fuc = &mut self.funcs[func];
+                    debug_assert!(!fuc.code.is_empty());
+                    if fuc.offset != u32::MAX {
+                        continue;
+                    }
+                    fuc.offset = 0;
+                    self.asm.funcs.push(func);
+                    self.asm.frontier.extend(fuc.relocs.iter().map(|r| r.target));
+                }
+                ty::Kind::Global(glob) => {
+                    let glb = &mut self.globals[glob];
+                    if glb.offset != u32::MAX {
+                        continue;
+                    }
+                    glb.offset = 0;
+                    self.asm.globals.push(glob);
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        let init_len = to.len();
+
+        for &func in &self.asm.funcs {
+            let fuc = &mut self.funcs[func];
+            fuc.offset = to.len() as _;
+            debug_assert!(!fuc.code.is_empty());
+            to.extend(&fuc.code);
+        }
+
+        let code_length = to.len() - init_len;
+
+        for global in self.asm.globals.drain(..) {
+            self.globals[global].offset = to.len() as _;
+            to.extend(&types.ins.globals[global].data);
+        }
+
+        let data_length = to.len() - code_length - init_len;
+
+        for func in self.asm.funcs.drain(..) {
+            let fuc = &self.funcs[func];
+            for rel in &fuc.relocs {
+                let offset = match rel.target.expand() {
+                    ty::Kind::Func(fun) => self.funcs[fun].offset,
+                    ty::Kind::Global(glo) => self.globals[glo].offset,
+                    _ => unreachable!(),
+                };
+                rel.reloc.apply_jump(to, offset, fuc.offset);
+            }
+        }
+
+        AssemblySpec {
+            code_length: code_length as _,
+            data_length: data_length as _,
+            entry: self.funcs[from].offset,
+        }
+    }
+
+    fn disasm<'a>(
+        &'a self,
+        mut sluce: &[u8],
+        eca_handler: &mut dyn FnMut(&mut &[u8]),
+        types: &'a Types,
+        files: &'a EntSlice<Module, parser::Ast>,
+        output: &mut String,
+    ) -> Result<(), alloc::boxed::Box<dyn error::Error + Send + Sync + 'a>> {
+        use hbbytecode::DisasmItem;
+        let functions = types
+            .ins
+            .funcs
+            .values()
+            .zip(self.funcs.values())
+            .filter(|(_, f)| f.offset != u32::MAX)
+            .map(|(f, fd)| {
+                let name = if f.file != Module::default() {
+                    let file = &files[f.file];
+                    file.ident_str(f.name)
+                } else {
+                    "target_fn"
+                };
+                (fd.offset, (name, fd.code.len() as u32, DisasmItem::Func))
+            })
+            .chain(
+                types
+                    .ins
+                    .globals
+                    .values()
+                    .zip(self.globals.values())
+                    .filter(|(_, g)| g.offset != u32::MAX)
+                    .map(|(g, gd)| {
+                        let name = if g.file == Module::default() {
+                            core::str::from_utf8(&g.data).unwrap_or("invalid utf-8")
+                        } else {
+                            let file = &files[g.file];
+                            file.ident_str(g.name)
+                        };
+                        (gd.offset, (name, g.data.len() as Size, DisasmItem::Global))
+                    }),
+            )
+            .collect::<BTreeMap<_, _>>();
+        hbbytecode::disasm(&mut sluce, &functions, output, eca_handler).map_err(Into::into)
+    }
+
+    fn emit_ct_body(
+        &mut self,
+        id: ty::Func,
+        nodes: &Nodes,
+        tys: &Types,
+        files: &EntSlice<Module, parser::Ast>,
+    ) {
+        self.emit_body(id, nodes, tys, files);
+        let fd = &mut self.funcs[id];
+        fd.code.truncate(fd.code.len() - instrs::jala(0, 0, 0).0);
+        emit(&mut fd.code, instrs::tx());
+    }
+
+    fn emit_body(
+        &mut self,
+        id: ty::Func,
+        nodes: &Nodes,
+        tys: &Types,
+        files: &EntSlice<Module, parser::Ast>,
+    ) {
+        let sig = tys.ins.funcs[id].sig;
+
+        debug_assert!(self.code.is_empty());
+
+        self.offsets.clear();
+        self.offsets.resize(nodes.len(), Offset::MAX);
+
+        let mut stack_size = 0;
+        '_compute_stack: {
+            let mems = &nodes[MEM].outputs;
+            for &stck in mems.iter() {
+                if !matches!(nodes[stck].kind, Kind::Stck | Kind::Arg) {
+                    debug_assert_matches!(
+                        nodes[stck].kind,
+                        Kind::Phi
+                            | Kind::Return { .. }
+                            | Kind::Load
+                            | Kind::Call { .. }
+                            | Kind::Stre
+                            | Kind::Join
+                    );
+                    continue;
+                }
+                stack_size += tys.size_of(nodes[stck].ty);
+                self.offsets[stck as usize] = stack_size;
+            }
+            for &stck in mems.iter() {
+                if !matches!(nodes[stck].kind, Kind::Stck | Kind::Arg) {
+                    continue;
+                }
+                self.offsets[stck as usize] = stack_size - self.offsets[stck as usize];
+            }
+        }
+
+        let (saved, tail) = self.emit_body_code(nodes, sig, tys, files);
+
+        if let Some(last_ret) = self.ret_relocs.last()
+            && last_ret.offset as usize == self.code.len() - 5
+            && self
+                .jump_relocs
+                .last()
+                .is_none_or(|&(r, _)| self.offsets[r as usize] as usize != self.code.len())
+        {
+            self.code.truncate(self.code.len() - 5);
+            self.ret_relocs.pop();
+        }
+
+        for (nd, rel) in self.jump_relocs.drain(..) {
+            let offset = self.offsets[nd as usize];
+            rel.apply_jump(&mut self.code, offset, 0);
+        }
+
+        let end = self.code.len();
+        for ret_rel in self.ret_relocs.drain(..) {
+            ret_rel.apply_jump(&mut self.code, end as _, 0);
+        }
+
+        let mut stripped_prelude_size = 0;
+        '_close_function: {
+            let pushed = (saved as i64 + !tail as i64) * 8;
+            let stack = stack_size as i64;
+
+            let add_len = instrs::addi64(0, 0, 0).0;
+            let st_len = instrs::st(0, 0, 0, 0).0;
+
+            match (pushed, stack) {
+                (0, 0) => {
+                    stripped_prelude_size = add_len + st_len;
+                    self.code.drain(0..stripped_prelude_size);
+                    break '_close_function;
+                }
+                (0, stack) => {
+                    write_reloc(&mut self.code, 3, -stack, 8);
+                    stripped_prelude_size = st_len;
+                    let end = add_len + st_len;
+                    self.code.drain(add_len..end);
+                    self.emit(instrs::addi64(reg::STACK_PTR, reg::STACK_PTR, stack as _));
+                    break '_close_function;
+                }
+                _ => {}
+            }
+
+            write_reloc(&mut self.code, 3, -(pushed + stack), 8);
+            write_reloc(&mut self.code, 3 + 8 + 3, stack, 8);
+            write_reloc(&mut self.code, 3 + 8 + 3 + 8, pushed, 2);
+
+            self.emit(instrs::ld(
+                reg::RET_ADDR + tail as u8,
+                reg::STACK_PTR,
+                stack as _,
+                pushed as _,
+            ));
+            self.emit(instrs::addi64(reg::STACK_PTR, reg::STACK_PTR, (pushed + stack) as _));
+        }
+        self.relocs.iter_mut().for_each(|r| r.reloc.offset -= stripped_prelude_size as u32);
+        if sig.ret != ty::Id::NEVER {
+            self.emit(instrs::jala(reg::ZERO, reg::RET_ADDR, 0));
+        }
+
+        self.funcs.shadow(tys.ins.funcs.len());
+        self.funcs[id].code = mem::take(&mut self.code);
+        self.funcs[id].relocs = mem::take(&mut self.relocs);
+
+        debug_assert_eq!(self.ret_relocs.len(), 0);
+        debug_assert_eq!(self.relocs.len(), 0);
+        debug_assert_eq!(self.jump_relocs.len(), 0);
+        debug_assert_eq!(self.code.len(), 0);
+    }
+}
+
+impl Nodes {
+    fn cond_op(&self, cnd: Nid) -> CondRet {
+        let Kind::BinOp { op } = self[cnd].kind else { return None };
+        if self.is_unlocked(cnd) {
+            return None;
+        }
+        op.cond_op(self[self[cnd].inputs[1]].ty)
+    }
+
+    fn strip_offset(&self, region: Nid) -> (Nid, Offset) {
+        if matches!(self[region].kind, Kind::BinOp { op: TokenKind::Add | TokenKind::Sub })
+            && self.is_locked(region)
+            && let Kind::CInt { value } = self[self[region].inputs[2]].kind
+        {
+            (self[region].inputs[1], value as _)
+        } else {
+            (region, 0)
+        }
+    }
+
+    fn is_never_used(&self, nid: Nid, tys: &Types) -> bool {
+        let node = &self[nid];
+        match node.kind {
+            Kind::CInt { value: 0 } => false,
+            Kind::CInt { value: 1.. } => node.outputs.iter().all(|&o| {
+                matches!(self[o].kind, Kind::BinOp { op }
+                        if op.imm_binop(self[o].ty).is_some()
+                            && self.is_const(self[o].inputs[2])
+                            && op.cond_op(self[o].ty).is_none())
+            }),
+            Kind::BinOp { op: TokenKind::Mul } if node.ty.is_float() => {
+                node.outputs.iter().all(|&n| {
+                    self[n].kind == Kind::BinOp { op: TokenKind::Add } && self[n].inputs[1] == nid
+                })
+            }
+            Kind::BinOp { op: TokenKind::Add | TokenKind::Sub } => {
+                (self.is_locked(node.inputs[1]) && !self[node.inputs[1]].ty.is_float())
+                    || (self.is_const(node.inputs[2])
+                        && node.outputs.iter().all(|&n| self.uses_direct_offset_of(n, nid, tys)))
+            }
+            Kind::BinOp { op } => {
+                op.cond_op(self[node.inputs[1]].ty).is_some()
+                    && node.outputs.iter().all(|&n| self[n].kind == Kind::If)
+            }
+            Kind::Stck if tys.size_of(node.ty) == 0 => true,
+            Kind::Stck | Kind::Arg => node.outputs.iter().all(|&n| {
+                self.uses_direct_offset_of(n, nid, tys)
+                    || (matches!(self[n].kind, Kind::BinOp { op: TokenKind::Add })
+                        && self.is_never_used(n, tys))
+            }),
+            Kind::Load { .. } => node.ty.loc(tys) == Loc::Stack,
+            _ => false,
+        }
+    }
+
+    fn uses_direct_offset_of(&self, user: Nid, target: Nid, tys: &Types) -> bool {
+        let node = &self[user];
+        ((node.kind == Kind::Stre && node.inputs[2] == target)
+            || (node.kind == Kind::Load && node.inputs[1] == target))
+            && (node.ty.loc(tys) == Loc::Reg
+               //  this means the struct is actually loaded into a register so no BMC needed
+                || (node.kind == Kind::Load
+                    && !matches!(tys.parama(node.ty).0, Some(PLoc::Ref(..)))
+                    && node.outputs.iter().all(|&o| matches!(self[o].kind, Kind::Call { .. } | Kind::Return { .. }))))
+    }
+}
+
+impl HbvmBackend {
+    fn extend(
+        &mut self,
+        base: ty::Id,
+        dest: ty::Id,
+        reg: Reg,
+        tys: &Types,
+        files: &EntSlice<Module, parser::Ast>,
+    ) {
+        if reg == 0 {
+            return;
+        }
+
+        let (bsize, dsize) = (tys.size_of(base), tys.size_of(dest));
+        debug_assert!(bsize <= 8, "{}", ty::Display::new(tys, files, base));
+        debug_assert!(dsize <= 8, "{}", ty::Display::new(tys, files, dest));
+        if bsize == dsize {
+            return Default::default();
+        }
+        self.emit(match (base.is_signed(), dest.is_signed()) {
+            (true, true) => {
+                let op = [instrs::sxt8, instrs::sxt16, instrs::sxt32][bsize.ilog2() as usize];
+                op(reg, reg)
+            }
+            _ => {
+                let mask = (1u64 << (bsize * 8)) - 1;
+                instrs::andi(reg, reg, mask)
+            }
+        });
+    }
+}
+
+type CondRet = Option<(fn(u8, u8, i16) -> EncodedInstr, bool)>;
+
+impl TokenKind {
+    fn cmp_against(self) -> Option<u64> {
+        Some(match self {
+            Self::Le | Self::Gt => 1,
+            Self::Ne | Self::Eq => 0,
+            Self::Ge | Self::Lt => (-1i64) as _,
+            _ => return None,
+        })
+    }
+
+    fn float_cmp(self, ty: ty::Id) -> Option<fn(u8, u8, u8) -> EncodedInstr> {
+        if !ty.is_float() {
+            return None;
+        }
+        let size = ty.simple_size().unwrap();
+
+        let ops = match self {
+            Self::Gt => [instrs::fcmpgt32, instrs::fcmpgt64],
+            Self::Lt => [instrs::fcmplt32, instrs::fcmplt64],
+            _ => return None,
+        };
+
+        Some(ops[size.ilog2() as usize - 2])
+    }
+
+    fn cond_op(self, ty: ty::Id) -> CondRet {
+        let signed = ty.is_signed();
+        Some((
+            match self {
+                Self::Eq => instrs::jne,
+                Self::Ne => instrs::jeq,
+                _ if ty.is_float() => return None,
+                Self::Le if signed => instrs::jgts,
+                Self::Le => instrs::jgtu,
+                Self::Lt if signed => instrs::jlts,
+                Self::Lt => instrs::jltu,
+                Self::Ge if signed => instrs::jlts,
+                Self::Ge => instrs::jltu,
+                Self::Gt if signed => instrs::jgts,
+                Self::Gt => instrs::jgtu,
+                _ => return None,
+            },
+            matches!(self, Self::Lt | Self::Gt),
+        ))
+    }
+
+    fn binop(self, ty: ty::Id) -> Option<fn(u8, u8, u8) -> EncodedInstr> {
+        let size = ty.simple_size().unwrap_or_else(|| panic!("{:?}", ty.expand()));
+        if ty.is_integer() || ty == ty::Id::BOOL || ty.is_pointer() {
+            macro_rules! div { ($($op:ident),*) => {[$(|a, b, c| $op(a, 0, b, c)),*]}; }
+            macro_rules! rem { ($($op:ident),*) => {[$(|a, b, c| $op(0, a, b, c)),*]}; }
+            let signed = ty.is_signed();
+
+            let ops = match self {
+                Self::Add => [add8, add16, add32, add64],
+                Self::Sub => [sub8, sub16, sub32, sub64],
+                Self::Mul => [mul8, mul16, mul32, mul64],
+                Self::Div if signed => div!(dirs8, dirs16, dirs32, dirs64),
+                Self::Div => div!(diru8, diru16, diru32, diru64),
+                Self::Mod if signed => rem!(dirs8, dirs16, dirs32, dirs64),
+                Self::Mod => rem!(diru8, diru16, diru32, diru64),
+                Self::Band => return Some(and),
+                Self::Bor => return Some(or),
+                Self::Xor => return Some(xor),
+                Self::Shl => [slu8, slu16, slu32, slu64],
+                Self::Shr if signed => [srs8, srs16, srs32, srs64],
+                Self::Shr => [sru8, sru16, sru32, sru64],
+                _ => return None,
+            };
+
+            Some(ops[size.ilog2() as usize])
+        } else {
+            debug_assert!(ty.is_float(), "{self} {ty:?}");
+            let ops = match self {
+                Self::Add => [fadd32, fadd64],
+                Self::Sub => [fsub32, fsub64],
+                Self::Mul => [fmul32, fmul64],
+                Self::Div => [fdiv32, fdiv64],
+                _ => return None,
+            };
+            Some(ops[size.ilog2() as usize - 2])
+        }
+    }
+
+    fn imm_binop(self, ty: ty::Id) -> Option<fn(u8, u8, u64) -> EncodedInstr> {
+        macro_rules! def_op {
+            ($name:ident |$a:ident, $b:ident, $c:ident| $($tt:tt)*) => {
+                macro_rules! $name {
+                    ($$($$op:ident),*) => {
+                        [$$(
+                            |$a, $b, $c: u64| $$op($($tt)*),
+                        )*]
+                    }
+                }
+            };
+        }
+
+        if ty.is_float() {
+            return None;
+        }
+
+        def_op!(basic_op | a, b, c | a, b, c as _);
+        def_op!(sub_op | a, b, c | a, b, c.wrapping_neg() as _);
+
+        let signed = ty.is_signed();
+        let ops = match self {
+            Self::Add => basic_op!(addi8, addi16, addi32, addi64),
+            Self::Sub => sub_op!(addi8, addi16, addi32, addi64),
+            Self::Mul => basic_op!(muli8, muli16, muli32, muli64),
+            Self::Band => return Some(andi),
+            Self::Bor => return Some(ori),
+            Self::Xor => return Some(xori),
+            Self::Shr if signed => basic_op!(srsi8, srsi16, srsi32, srsi64),
+            Self::Shr => basic_op!(srui8, srui16, srui32, srui64),
+            Self::Shl => basic_op!(slui8, slui16, slui32, slui64),
+            _ => return None,
+        };
+
+        let size = ty.simple_size().unwrap();
+        Some(ops[size.ilog2() as usize])
+    }
+
+    fn unop(&self, dst: ty::Id, src: ty::Id, tys: &Types) -> Option<fn(u8, u8) -> EncodedInstr> {
+        let src_idx = tys.size_of(src).ilog2() as usize;
+        Some(match self {
+            Self::Sub => [
+                |a, b| sub8(a, reg::ZERO, b),
+                |a, b| sub16(a, reg::ZERO, b),
+                |a, b| sub32(a, reg::ZERO, b),
+                |a, b| sub64(a, reg::ZERO, b),
+            ][src_idx],
+            Self::Not => instrs::not,
+            Self::Float if dst.is_float() && src.is_integer() => {
+                debug_assert_matches!(
+                    (dst.simple_size(), src.simple_size()),
+                    (Some(4 | 8), Some(8))
+                );
+                [instrs::itf32, instrs::itf64][dst.simple_size().unwrap().ilog2() as usize - 2]
+            }
+            Self::Number if src.is_float() && dst.is_integer() => {
+                [|a, b| instrs::fti32(a, b, 1), |a, b| instrs::fti64(a, b, 1)][src_idx - 2]
+            }
+            Self::Number if src.is_signed() && (dst.is_integer() || dst.is_pointer()) => {
+                [instrs::sxt8, instrs::sxt16, instrs::sxt32][src_idx]
+            }
+            Self::Number
+                if (src.is_unsigned() || src == ty::Id::BOOL)
+                    && (dst.is_integer() || dst.is_pointer()) =>
+            {
+                [
+                    |a, b| instrs::andi(a, b, 0xff),
+                    |a, b| instrs::andi(a, b, 0xffff),
+                    |a, b| instrs::andi(a, b, 0xffffffff),
+                ][src_idx]
+            }
+            Self::Float if dst.is_float() && src.is_float() => {
+                [instrs::fc32t64, |a, b| instrs::fc64t32(a, b, 1)][src_idx - 2]
+            }
+            _ => return None,
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum PLoc {
+    Reg(Reg, u16),
+    WideReg(Reg, u16),
+    Ref(Reg, u32),
+}
+
+impl PLoc {
+    fn reg(self) -> u8 {
+        match self {
+            PLoc::Reg(r, _) | PLoc::WideReg(r, _) | PLoc::Ref(r, _) => r,
+        }
+    }
+}
+
+struct ParamAlloc(Range<Reg>);
+
+impl ParamAlloc {
+    pub fn next(&mut self, ty: ty::Id, tys: &Types) -> Option<PLoc> {
+        Some(match tys.size_of(ty) {
+            0 => return None,
+            size @ 1..=8 => PLoc::Reg(self.0.next().unwrap(), size as _),
+            size @ 9..=16 => PLoc::WideReg(self.0.next_chunk::<2>().unwrap()[0], size as _),
+            size @ 17.. => PLoc::Ref(self.0.next().unwrap(), size),
+        })
+    }
+}
+
+impl Types {
+    fn parama(&self, ret: ty::Id) -> (Option<PLoc>, ParamAlloc) {
+        let mut iter = ParamAlloc(1..12);
+        let ret = iter.next(ret, self);
+        iter.0.start += ret.is_none() as u8;
+        (ret, iter)
+    }
+}
+
+type EncodedInstr = (usize, [u8; instrs::MAX_SIZE]);
+fn emit(out: &mut Vec<u8>, (len, instr): EncodedInstr) {
+    out.extend_from_slice(&instr[..len]);
+}
+
+fn binary_prelude(to: &mut Vec<u8>) {
+    emit(to, instrs::jal(reg::RET_ADDR, reg::ZERO, 0));
+    emit(to, instrs::tx());
+}
+
+#[derive(Default)]
+pub struct LoggedMem {
+    pub mem: hbvm::mem::HostMemory,
+    logger: hbvm::mem::InstrLogger,
+}
+
+impl hbvm::mem::Memory for LoggedMem {
+    unsafe fn load(
+        &mut self,
+        addr: hbvm::mem::Address,
+        target: *mut u8,
+        count: usize,
+    ) -> Result<(), hbvm::mem::LoadError> {
+        log::trace!(
+            "load: {:x} {}",
+            addr.get(),
+            AsHex(core::slice::from_raw_parts(addr.get() as *const u8, count))
+        );
+        self.mem.load(addr, target, count)
+    }
+
+    unsafe fn store(
+        &mut self,
+        addr: hbvm::mem::Address,
+        source: *const u8,
+        count: usize,
+    ) -> Result<(), hbvm::mem::StoreError> {
+        log::trace!(
+            "store: {:x} {}",
+            addr.get(),
+            AsHex(core::slice::from_raw_parts(source, count))
+        );
+        self.mem.store(addr, source, count)
+    }
+
+    unsafe fn prog_read<T: Copy + 'static>(&mut self, addr: hbvm::mem::Address) -> T {
+        self.mem.prog_read(addr)
+    }
+
+    fn log_instr(&mut self, at: hbvm::mem::Address, regs: &[hbvm::value::Value]) {
+        log::trace!("read-typed: {:x}: {}", at.get(), unsafe {
+            self.logger.display_instr(at, regs)
+        });
+    }
+}
+
+struct AsHex<'a>(&'a [u8]);
+
+impl core::fmt::Display for AsHex<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        for &b in self.0 {
+            write!(f, "{b:02x}")?;
+        }
+        Ok(())
+    }
+}
+
+const VM_STACK_SIZE: usize = 1024 * 64;
+
+pub struct Comptime {
+    pub vm: hbvm::Vm<LoggedMem, { 1024 * 10 }>,
+    stack: Box<[u8; VM_STACK_SIZE]>,
+    pub code: Vec<u8>,
+    depth: usize,
+}
+
+impl Comptime {
+    pub fn run(&mut self, ret_loc: &mut [u8], offset: u32) -> u64 {
+        self.vm.write_reg(reg::RET, ret_loc.as_mut_ptr() as u64);
+        let prev_pc = self.push_pc(offset);
+        loop {
+            match self.vm.run().expect("TODO") {
+                hbvm::VmRunOk::End => break,
+                hbvm::VmRunOk::Timer => todo!(),
+                hbvm::VmRunOk::Ecall => todo!(),
+                hbvm::VmRunOk::Breakpoint => todo!(),
+            }
+        }
+        self.pop_pc(prev_pc);
+
+        if let len @ 1..=8 = ret_loc.len() {
+            ret_loc.copy_from_slice(&self.vm.read_reg(reg::RET).0.to_ne_bytes()[..len])
+        }
+
+        self.vm.read_reg(reg::RET).0
+    }
+
+    pub fn reset(&mut self) {
+        let ptr = unsafe { self.stack.as_mut_ptr().cast::<u8>().add(VM_STACK_SIZE) as u64 };
+        self.vm.registers.fill(hbvm::value::Value(0));
+        self.vm.write_reg(reg::STACK_PTR, ptr);
+        self.vm.pc = hbvm::mem::Address::new(self.code.as_ptr() as u64 + HEADER_SIZE as u64);
+    }
+
+    fn push_pc(&mut self, offset: Offset) -> hbvm::mem::Address {
+        let entry = &mut self.code[offset as usize] as *mut _ as _;
+        core::mem::replace(&mut self.vm.pc, hbvm::mem::Address::new(entry))
+            - self.code.as_ptr() as usize
+    }
+
+    fn pop_pc(&mut self, prev_pc: hbvm::mem::Address) {
+        self.vm.pc = prev_pc + self.code.as_ptr() as usize;
+    }
+
+    pub fn clear(&mut self) {
+        self.code.clear();
+    }
+
+    #[must_use]
+    pub fn active(&self) -> bool {
+        self.depth != 0
+    }
+
+    pub fn activate(&mut self) {
+        self.depth += 1;
+    }
+
+    pub fn deactivate(&mut self) {
+        self.depth -= 1;
+    }
+}
+
+impl Default for Comptime {
+    fn default() -> Self {
+        let mut stack = Box::<[u8; VM_STACK_SIZE]>::new_uninit();
+        let mut vm = hbvm::Vm::default();
+        let ptr = unsafe { stack.as_mut_ptr().cast::<u8>().add(VM_STACK_SIZE) as u64 };
+        vm.write_reg(reg::STACK_PTR, ptr);
+        Self { vm, stack: unsafe { stack.assume_init() }, code: Default::default(), depth: 0 }
+    }
+}
+
+const HEADER_SIZE: usize = core::mem::size_of::<AbleOsExecutableHeader>();
+
+#[repr(packed)]
+#[expect(dead_code)]
+pub struct AbleOsExecutableHeader {
+    magic_number: [u8; 3],
+    executable_version: u32,
+
+    code_length: u64,
+    data_length: u64,
+    debug_length: u64,
+    config_length: u64,
+    metadata_length: u64,
+}
+
+#[cfg(test)]
+pub fn test_run_vm(out: &[u8], output: &mut String) {
+    use core::{ffi::CStr, fmt::Write};
+
+    let mut stack = [0_u64; 1024 * 20];
+
+    let mut vm = unsafe {
+        hbvm::Vm::<_, { 1024 * 100 }>::new(
+            LoggedMem::default(),
+            hbvm::mem::Address::new(out.as_ptr() as u64).wrapping_add(HEADER_SIZE),
+        )
+    };
+
+    vm.write_reg(reg::STACK_PTR, unsafe { stack.as_mut_ptr().add(stack.len()) } as u64);
+
+    let stat = loop {
+        match vm.run() {
+            Ok(hbvm::VmRunOk::End) => break Ok(()),
+            Ok(hbvm::VmRunOk::Ecall) => match vm.read_reg(2).0 {
+                37 => writeln!(
+                    output,
+                    "{}",
+                    unsafe { CStr::from_ptr(vm.read_reg(3).0 as _) }.to_str().unwrap()
+                )
+                .unwrap(),
+                1 => writeln!(output, "ev: Ecall").unwrap(), // compatibility with a test
+                69 => {
+                    let [size, align] = [vm.read_reg(3).0 as usize, vm.read_reg(4).0 as usize];
+                    let layout = core::alloc::Layout::from_size_align(size, align).unwrap();
+                    let ptr = unsafe { alloc::alloc::alloc(layout) };
+                    vm.write_reg(1, ptr as u64);
+                }
+                96 => {
+                    let [ptr, size, align] = [
+                        vm.read_reg(3).0 as usize,
+                        vm.read_reg(4).0 as usize,
+                        vm.read_reg(5).0 as usize,
+                    ];
+
+                    let layout = core::alloc::Layout::from_size_align(size, align).unwrap();
+                    unsafe { alloc::alloc::dealloc(ptr as *mut u8, layout) };
+                }
+                3 => vm.write_reg(1, 42),
+                8 => {}
+                unknown => writeln!(output, "unknown ecall: {unknown:?}").unwrap(),
+            },
+            Ok(hbvm::VmRunOk::Timer) => {
+                writeln!(output, "timed out").unwrap();
+                break Ok(());
+            }
+            Ok(ev) => writeln!(output, "ev: {:?}", ev).unwrap(),
+            Err(e) => break Err(e),
+        }
+    };
+
+    writeln!(output, "code size: {}", out.len() - HEADER_SIZE).unwrap();
+    writeln!(output, "ret: {:?}", vm.read_reg(1).0).unwrap();
+    writeln!(output, "status: {:?}", stat).unwrap();
+}

lang/src/fmt.rs

@@ -0,0 +1,675 @@
+use {
+    crate::{
+        lexer::{self, Lexer, TokenKind},
+        parser::{
+            self, CommentOr, CtorField, EnumField, Expr, FieldList, ListKind, Poser, Radix,
+            StructField, UnionField,
+        },
+    },
+    core::{
+        fmt::{self},
+        mem,
+    },
+};
+
+pub fn display_radix(radix: Radix, mut value: u64, buf: &mut [u8; 64]) -> &str {
+    fn conv_radix(d: u8) -> u8 {
+        match d {
+            0..=9 => d + b'0',
+            _ => d - 10 + b'A',
+        }
+    }
+
+    for (i, b) in buf.iter_mut().enumerate().rev() {
+        let d = (value % radix as u64) as u8;
+        value /= radix as u64;
+        *b = conv_radix(d);
+        if value == 0 {
+            return unsafe { core::str::from_utf8_unchecked(&buf[i..]) };
+        }
+    }
+
+    unreachable!()
+}
+
+#[repr(u8)]
+enum TokenGroup {
+    Blank,
+    Comment,
+    Keyword,
+    Identifier,
+    Directive,
+    Number,
+    String,
+    Op,
+    Assign,
+    Paren,
+    Bracket,
+    Colon,
+    Comma,
+    Dot,
+    Ctor,
+}
+
+impl TokenKind {
+    fn to_higlight_group(self) -> TokenGroup {
+        use {TokenGroup as TG, TokenKind::*};
+        match self {
+            BSlash | Pound | Eof | Ct => TG::Blank,
+            Comment => TG::Comment,
+            Directive => TG::Directive,
+            Colon => TG::Colon,
+            Semi | Comma => TG::Comma,
+            Dot => TG::Dot,
+            Ctor | Arr | Tupl | TArrow | Range => TG::Ctor,
+            LParen | RParen => TG::Paren,
+            LBrace | RBrace | LBrack | RBrack => TG::Bracket,
+            Number | Float => TG::Number,
+            Under | CtIdent | Ident => TG::Identifier,
+            Tick | Tilde | Que | Not | Mod | Band | Bor | Xor | Mul | Add | Sub | Div | Shl
+            | Shr | Or | And | Lt | Gt | Eq | Le | Ge | Ne => TG::Op,
+            Decl | Assign | BorAss | XorAss | BandAss | AddAss | SubAss | MulAss | DivAss
+            | ModAss | ShrAss | ShlAss => TG::Assign,
+            DQuote | Quote => TG::String,
+            Slf | Defer | Return | If | Else | Loop | Break | Continue | Fn | Idk | Die
+            | Struct | Packed | True | False | Null | Match | Enum | Union | CtLoop => TG::Keyword,
+        }
+    }
+}
+
+pub fn get_token_kinds(mut source: &mut [u8]) -> usize {
+    let len = source.len();
+    loop {
+        let src = unsafe { core::str::from_utf8_unchecked(source) };
+        let mut token = lexer::Lexer::new(src).eat();
+        match token.kind {
+            TokenKind::Eof => break,
+            // ???
+            TokenKind::CtIdent | TokenKind::Directive => token.start -= 1,
+            _ => {}
+        }
+        let start = token.start as usize;
+        let end = token.end as usize;
+        source[..start].fill(0);
+        source[start..end].fill(token.kind.to_higlight_group() as u8);
+        source = &mut source[end..];
+    }
+    len
+}
+
+pub fn minify(source: &mut str) -> usize {
+    fn needs_space(c: u8) -> bool {
+        matches!(c, b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | 127..)
+    }
+
+    let mut writer = source.as_mut_ptr();
+    let mut reader = &source[..];
+    let mut prev_needs_whitecpace = false;
+    let mut prev_needs_newline = false;
+    loop {
+        let mut token = lexer::Lexer::new(reader).eat();
+        match token.kind {
+            TokenKind::Eof => break,
+            TokenKind::CtIdent | TokenKind::CtLoop | TokenKind::Directive => token.start -= 1,
+            _ => {}
+        }
+
+        let cpy_len = token.range().len();
+
+        let mut prefix = 0;
+        if prev_needs_whitecpace && needs_space(reader.as_bytes()[token.start as usize]) {
+            prefix = b' ';
+            debug_assert!(token.start != 0, "{reader}");
+        }
+        prev_needs_whitecpace = needs_space(reader.as_bytes()[token.end as usize - 1]);
+
+        let inbetween_new_lines =
+            reader[..token.start as usize].bytes().filter(|&b| b == b'\n').count()
+                + token.kind.precedence().is_some() as usize;
+        let extra_prefix_new_lines = if inbetween_new_lines > 1 {
+            1 + token.kind.precedence().is_none() as usize
+        } else {
+            prev_needs_newline as usize
+        };
+
+        if token.kind == TokenKind::Comment && reader.as_bytes()[token.end as usize - 1] != b'/' {
+            prev_needs_newline = true;
+            prev_needs_whitecpace = false;
+        } else {
+            prev_needs_newline = false;
+        }
+
+        let sstr = reader[token.start as usize..].as_ptr();
+        reader = &reader[token.end as usize..];
+        unsafe {
+            if extra_prefix_new_lines != 0 {
+                for _ in 0..extra_prefix_new_lines {
+                    writer.write(b'\n');
+                    writer = writer.add(1);
+                }
+            } else if prefix != 0 {
+                writer.write(prefix);
+                writer = writer.add(1);
+            }
+            writer.copy_from(sstr, cpy_len);
+            writer = writer.add(cpy_len);
+        }
+    }
+
+    unsafe { writer.sub_ptr(source.as_mut_ptr()) }
+}
+
+pub struct Formatter<'a> {
+    source: &'a str,
+    depth: usize,
+}
+
+// we exclusively use `write_str` to reduce bloat
+impl<'a> Formatter<'a> {
+    pub fn new(source: &'a str) -> Self {
+        Self { source, depth: 0 }
+    }
+
+    fn fmt_list<T: Poser, F: core::fmt::Write>(
+        &mut self,
+        f: &mut F,
+        trailing: bool,
+        end: &str,
+        sep: &str,
+        list: &[T],
+        fmt: impl Fn(&mut Self, &T, &mut F) -> fmt::Result,
+    ) -> fmt::Result {
+        self.fmt_list_low(f, trailing, end, sep, list, |s, v, f| {
+            fmt(s, v, f)?;
+            Ok(true)
+        })
+    }
+
+    fn fmt_list_low<T: Poser, F: core::fmt::Write>(
+        &mut self,
+        f: &mut F,
+        trailing: bool,
+        end: &str,
+        sep: &str,
+        list: &[T],
+        fmt: impl Fn(&mut Self, &T, &mut F) -> Result<bool, fmt::Error>,
+    ) -> fmt::Result {
+        if !trailing {
+            let mut first = true;
+            for expr in list {
+                if !core::mem::take(&mut first) {
+                    f.write_str(sep)?;
+                    f.write_str(" ")?;
+                }
+                first = !fmt(self, expr, f)?;
+            }
+            return f.write_str(end);
+        }
+
+        if !end.is_empty() {
+            writeln!(f)?;
+        }
+
+        self.depth += !end.is_empty() as usize;
+        let mut already_indented = end.is_empty();
+        let res = (|| {
+            for (i, stmt) in list.iter().enumerate() {
+                if !mem::take(&mut already_indented) {
+                    for _ in 0..self.depth {
+                        f.write_str("\t")?;
+                    }
+                }
+                let add_sep = fmt(self, stmt, f)?;
+                if add_sep {
+                    f.write_str(sep)?;
+                }
+                if let Some(expr) = list.get(i + 1)
+                    && let Some(prev) = self.source.get(..expr.posi() as usize)
+                {
+                    if sep.is_empty() && prev.trim_end().ends_with(';') {
+                        f.write_str(";")?;
+                    }
+                    if count_trailing_newlines(prev) > 1 {
+                        f.write_str("\n")?;
+                    }
+                }
+                if add_sep {
+                    f.write_str("\n")?;
+                }
+            }
+            Ok(())
+        })();
+        self.depth -= !end.is_empty() as usize;
+
+        if !end.is_empty() {
+            for _ in 0..self.depth {
+                f.write_str("\t")?;
+            }
+            f.write_str(end)?;
+        }
+        res
+    }
+
+    fn fmt_paren<F: core::fmt::Write>(
+        &mut self,
+        expr: &Expr,
+        f: &mut F,
+        cond: impl FnOnce(&Expr) -> bool,
+    ) -> fmt::Result {
+        if cond(expr) {
+            f.write_str("(")?;
+            self.fmt(expr, f)?;
+            f.write_str(")")
+        } else {
+            self.fmt(expr, f)
+        }
+    }
+
+    fn fmt_fields<F: core::fmt::Write, T: Poser + Copy>(
+        &mut self,
+        f: &mut F,
+        keyword: &str,
+        trailing_comma: bool,
+        fields: FieldList<T>,
+        fmt: impl Fn(&mut Self, &T, &mut F) -> Result<(), fmt::Error>,
+    ) -> fmt::Result {
+        f.write_str(keyword)?;
+        f.write_str(" {")?;
+        self.fmt_list_low(f, trailing_comma, "}", ",", fields, |s, field, f| {
+            match field {
+                CommentOr::Or(Ok(field)) => fmt(s, field, f)?,
+                CommentOr::Or(Err(scope)) => {
+                    s.fmt_list(f, true, "", "", scope, Self::fmt)?;
+                    return Ok(false);
+                }
+                CommentOr::Comment { literal, .. } => {
+                    f.write_str(literal)?;
+                    f.write_str("\n")?;
+                }
+            }
+            Ok(field.or().is_some())
+        })
+    }
+
+    pub fn fmt<F: core::fmt::Write>(&mut self, expr: &Expr, f: &mut F) -> fmt::Result {
+        macro_rules! impl_parenter {
+            ($($name:ident => $pat:pat,)*) => {
+                $(
+                    let $name = |e: &Expr| matches!(e, $pat);
+                )*
+            };
+        }
+
+        impl_parenter! {
+            unary => Expr::BinOp { .. },
+            postfix => Expr::UnOp { .. } | Expr::BinOp { .. },
+            consecutive => Expr::UnOp { .. },
+        }
+
+        match *expr {
+            Expr::Defer { value, .. } => {
+                f.write_str("defer ")?;
+                self.fmt(value, f)
+            }
+            Expr::Slf { .. } => f.write_str("Self"),
+            Expr::String { literal, .. } => f.write_str(literal),
+            Expr::Char { literal, .. } => f.write_str(literal),
+            Expr::Comment { literal, .. } => f.write_str(literal),
+            Expr::Mod { path, .. } => write!(f, "@use(\"{path}\")"),
+            Expr::Embed { path, .. } => write!(f, "@embed(\"{path}\")"),
+            Expr::Field { target, name: field, .. } => {
+                self.fmt_paren(target, f, postfix)?;
+                f.write_str(".")?;
+                f.write_str(field)
+            }
+            Expr::Range { start, end, .. } => {
+                if let Some(start) = start {
+                    self.fmt(start, f)?;
+                }
+                f.write_str("..")?;
+                if let Some(end) = end {
+                    self.fmt(end, f)?;
+                }
+                Ok(())
+            }
+            Expr::Directive { name, args, .. } => {
+                f.write_str("@")?;
+                f.write_str(name)?;
+                f.write_str("(")?;
+                self.fmt_list(f, false, ")", ",", args, Self::fmt)
+            }
+            Expr::Struct { fields, trailing_comma, packed, .. } => {
+                if packed {
+                    f.write_str("packed ")?;
+                }
+
+                self.fmt_fields(
+                    f,
+                    "struct",
+                    trailing_comma,
+                    fields,
+                    |s, StructField { name, ty, default_value, .. }, f| {
+                        f.write_str(name)?;
+                        f.write_str(": ")?;
+                        s.fmt(ty, f)?;
+                        if let Some(deva) = default_value {
+                            f.write_str(" = ")?;
+                            s.fmt(deva, f)?;
+                        }
+                        Ok(())
+                    },
+                )
+            }
+            Expr::Union { fields, trailing_comma, .. } => self.fmt_fields(
+                f,
+                "union",
+                trailing_comma,
+                fields,
+                |s, UnionField { name, ty, .. }, f| {
+                    f.write_str(name)?;
+                    f.write_str(": ")?;
+                    s.fmt(ty, f)
+                },
+            ),
+            Expr::Enum { variants, trailing_comma, .. } => self.fmt_fields(
+                f,
+                "enum",
+                trailing_comma,
+                variants,
+                |_, EnumField { name, .. }, f| f.write_str(name),
+            ),
+            Expr::Ctor { ty, fields, trailing_comma, .. } => {
+                if let Some(ty) = ty {
+                    self.fmt_paren(ty, f, postfix)?;
+                }
+                f.write_str(".{")?;
+                self.fmt_list(
+                    f,
+                    trailing_comma,
+                    "}",
+                    ",",
+                    fields,
+                    |s: &mut Self, CtorField { name, value, .. }: &_, f| {
+                        f.write_str(name)?;
+                        if !matches!(value, &Expr::Ident { id, .. } if *name == &self.source[id.range()]) {
+                            f.write_str(": ")?;
+                            s.fmt(value, f)?;
+                        }
+                        Ok(())
+                    },
+                )
+            }
+            Expr::List {
+                pos,
+                kind: term,
+                ty: Some(&Expr::Slice { pos: spos, size: Some(&Expr::Number { value, .. }), item }),
+                fields,
+                trailing_comma,
+            } if value as usize == fields.len() => self.fmt(
+                &Expr::List {
+                    pos,
+                    kind: term,
+                    ty: Some(&Expr::Slice { pos: spos, size: None, item }),
+                    fields,
+                    trailing_comma,
+                },
+                f,
+            ),
+            Expr::List { ty, kind: term, fields, trailing_comma, .. } => {
+                if let Some(ty) = ty {
+                    self.fmt_paren(ty, f, postfix)?;
+                }
+                let (start, end) = match term {
+                    ListKind::Tuple => (".(", ")"),
+                    ListKind::Array => (".[", "]"),
+                };
+                f.write_str(start)?;
+                self.fmt_list(f, trailing_comma, end, ",", fields, Self::fmt)
+            }
+            Expr::Slice { item, size, .. } => {
+                f.write_str("[")?;
+                if let Some(size) = size {
+                    self.fmt(size, f)?;
+                }
+                f.write_str("]")?;
+                self.fmt_paren(item, f, unary)
+            }
+            Expr::Index { base, index } => {
+                self.fmt_paren(base, f, postfix)?;
+                f.write_str("[")?;
+                self.fmt(index, f)?;
+                f.write_str("]")
+            }
+            Expr::UnOp { op, val, .. } => {
+                f.write_str(op.name())?;
+                self.fmt_paren(val, f, unary)
+            }
+            Expr::Break { .. } => f.write_str("break"),
+            Expr::Continue { .. } => f.write_str("continue"),
+            Expr::If { cond, then, else_, .. } => {
+                f.write_str("if ")?;
+                self.fmt(cond, f)?;
+                f.write_str(" ")?;
+                self.fmt_paren(then, f, consecutive)?;
+                if let Some(e) = else_ {
+                    f.write_str(" else ")?;
+                    self.fmt(e, f)?;
+                }
+                Ok(())
+            }
+            Expr::Match { value, branches, .. } => {
+                f.write_str("match ")?;
+                self.fmt(value, f)?;
+                f.write_str(" {")?;
+                self.fmt_list(f, true, "}", ",", branches, |s, br, f| {
+                    s.fmt(&br.pat, f)?;
+                    f.write_str(" => ")?;
+                    s.fmt(&br.body, f)
+                })
+            }
+            Expr::Loop { body, unrolled, .. } => {
+                f.write_str(if unrolled { "$loop " } else { "loop " })?;
+                self.fmt(body, f)
+            }
+            Expr::Closure { ret, body, args, .. } => {
+                f.write_str("fn(")?;
+                self.fmt_list(f, false, "", ",", args, |s, arg, f| {
+                    if arg.is_ct {
+                        f.write_str("$")?;
+                    }
+                    f.write_str(arg.name)?;
+                    f.write_str(": ")?;
+                    s.fmt(&arg.ty, f)
+                })?;
+                f.write_str("): ")?;
+                self.fmt(ret, f)?;
+                f.write_str(" ")?;
+                self.fmt_paren(body, f, consecutive)?;
+                Ok(())
+            }
+            Expr::Call { func, args, trailing_comma } => {
+                self.fmt_paren(func, f, postfix)?;
+                f.write_str("(")?;
+                self.fmt_list(f, trailing_comma, ")", ",", args, Self::fmt)
+            }
+            Expr::Return { val: Some(val), .. } => {
+                f.write_str("return ")?;
+                self.fmt(val, f)
+            }
+            Expr::Return { val: None, .. } => f.write_str("return"),
+            Expr::Wildcard { .. } => f.write_str("_"),
+            Expr::Ident { pos, is_ct, .. } => {
+                if is_ct {
+                    f.write_str("$")?;
+                }
+                f.write_str(&self.source[Lexer::restore(self.source, pos).eat().range()])
+            }
+            Expr::Block { stmts, .. } => {
+                f.write_str("{")?;
+                self.fmt_list(f, true, "}", "", stmts, Self::fmt)
+            }
+            Expr::Number { value, radix, .. } => {
+                f.write_str(match radix {
+                    Radix::Decimal => "",
+                    Radix::Hex => "0x",
+                    Radix::Octal => "0o",
+                    Radix::Binary => "0b",
+                })?;
+                let mut buf = [0u8; 64];
+                f.write_str(display_radix(radix, value as u64, &mut buf))
+            }
+            Expr::Float { pos, .. } => {
+                f.write_str(&self.source[Lexer::restore(self.source, pos).eat().range()])
+            }
+            Expr::Bool { value, .. } => f.write_str(if value { "true" } else { "false" }),
+            Expr::Idk { .. } => f.write_str("idk"),
+            Expr::Die { .. } => f.write_str("die"),
+            Expr::Null { .. } => f.write_str("null"),
+            Expr::BinOp {
+                left,
+                op: TokenKind::Assign,
+                right: &Expr::BinOp { left: lleft, op, right, .. },
+                ..
+            } if left.pos() == lleft.pos() => {
+                self.fmt(left, f)?;
+                f.write_str(" ")?;
+                f.write_str(op.name())?;
+                f.write_str("= ")?;
+                self.fmt(right, f)
+            }
+            Expr::BinOp { right, op, left, .. } => {
+                let prec_miss_left = |e: &Expr| {
+                    matches!(
+                        e, Expr::BinOp { op: lop, .. } if op.precedence() > lop.precedence()
+                    )
+                };
+                let prec_miss_right = |e: &Expr| {
+                    matches!(
+                        e, Expr::BinOp { op: lop, .. }
+                            if (op.precedence() == lop.precedence() && !op.is_comutative())
+                                || op.precedence() > lop.precedence()
+                    )
+                };
+
+                self.fmt_paren(left, f, prec_miss_left)?;
+                if let Some(mut prev) = self.source.get(..right.pos() as usize) {
+                    prev = prev.trim_end();
+                    let estimate_bound =
+                        prev.rfind(|c: char| c.is_ascii_whitespace()).map_or(prev.len(), |i| i + 1);
+                    let exact_bound = lexer::Lexer::new(&prev[estimate_bound..]).last().start;
+                    prev = &prev[..exact_bound as usize + estimate_bound];
+                    if count_trailing_newlines(prev) > 0 {
+                        f.write_str("\n")?;
+                        for _ in 0..self.depth + 1 {
+                            f.write_str("\t")?;
+                        }
+                        f.write_str(op.name())?;
+                        f.write_str(" ")?;
+                    } else {
+                        if op != TokenKind::Colon {
+                            f.write_str(" ")?;
+                        }
+                        f.write_str(op.name())?;
+                        f.write_str(" ")?;
+                    }
+                } else {
+                    f.write_str(" ")?;
+                    f.write_str(op.name())?;
+                    f.write_str(" ")?;
+                }
+                self.fmt_paren(right, f, prec_miss_right)
+            }
+        }
+    }
+}
+
+pub fn count_trailing_newlines(source: &str) -> usize {
+    source[source.trim_end().len()..].bytes().filter(|&c| c == b'\n').count()
+}
+
+impl core::fmt::Display for parser::Ast {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt_file(self.exprs(), &self.file, f)
+    }
+}
+
+pub fn fmt_file(exprs: &[Expr], file: &str, f: &mut impl fmt::Write) -> fmt::Result {
+    for (i, expr) in exprs.iter().enumerate() {
+        Formatter::new(file).fmt(expr, f)?;
+        if let Some(expr) = exprs.get(i + 1)
+            && let Some(prefix) = file.get(..expr.pos() as usize)
+        {
+            if prefix.trim_end().ends_with(';') {
+                f.write_str(";")?;
+            }
+
+            if count_trailing_newlines(prefix) > 1 {
+                f.write_str("\n")?;
+            }
+        }
+
+        if i + 1 != exprs.len() {
+            writeln!(f)?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+pub mod test {
+    use {
+        crate::parser::{self, Ctx},
+        alloc::borrow::ToOwned,
+        std::{fmt::Write, string::String},
+    };
+
+    pub fn format(ident: &str, input: &str) {
+        let mut minned = input.to_owned();
+        let len = crate::fmt::minify(&mut minned);
+        minned.truncate(len);
+
+        let mut ctx = Ctx::default();
+        let ast = parser::Ast::new(ident, minned, &mut ctx, &mut parser::no_loader);
+        log::info!("{}", ctx.errors.borrow());
+        let mut output = String::new();
+        write!(output, "{ast}").unwrap();
+
+        let input_path = format!("formatter_{ident}.expected");
+        let output_path = format!("formatter_{ident}.actual");
+        std::fs::write(&input_path, input).unwrap();
+        std::fs::write(&output_path, output).unwrap();
+
+        let success = std::process::Command::new("diff")
+            .arg("-u")
+            .arg("--color")
+            .arg(&input_path)
+            .arg(&output_path)
+            .status()
+            .unwrap()
+            .success();
+        std::fs::remove_file(&input_path).unwrap();
+        std::fs::remove_file(&output_path).unwrap();
+        assert!(success, "test failed");
+    }
+
+    macro_rules! test {
+        ($($name:ident => $input:expr;)*) => {$(
+            #[test]
+            fn $name() {
+                format(stringify!($name), $input);
+            }
+        )*};
+    }
+
+    test! {
+        comments => "// comment\n// comment\n\n// comment\n\n\
+            /* comment */\n/* comment */\n\n/* comment */";
+        some_ordinary_code => "loft := fn(): int return loft(1, 2, 3)";
+        some_arg_per_line_code => "loft := fn(): int return loft(\
+            \n\t1,\n\t2,\n\t3,\n)";
+        some_ordinary_struct => "loft := fn(): int return loft.{a: 1, b: 2}";
+        some_ordinary_fild_per_lin_struct => "loft := fn(): int return loft.{\
+            \n\ta: 1,\n\tb: 2,\n}";
+        code_block => "loft := fn(): int {\n\tloft()\n\treturn 1\n}";
+    }
+}

lang/src/fs.rs

@@ -0,0 +1,390 @@
+use {
+    crate::{
+        backend::{hbvm::HbvmBackend, Backend},
+        parser::{Ast, Ctx, FileKind},
+        son::{self},
+        ty, FnvBuildHasher,
+    },
+    alloc::{string::String, vec::Vec},
+    core::{fmt::Write, ops::Deref},
+    hashbrown::hash_map,
+    std::{
+        borrow::ToOwned,
+        collections::VecDeque,
+        eprintln,
+        io::{self, Write as _},
+        path::{Path, PathBuf},
+        string::ToString,
+        sync::Mutex,
+    },
+};
+
+type HashMap<K, V> = hashbrown::HashMap<K, V, FnvBuildHasher>;
+
+pub struct Logger;
+
+impl log::Log for Logger {
+    fn enabled(&self, _: &log::Metadata) -> bool {
+        true
+    }
+
+    fn log(&self, record: &log::Record) {
+        if self.enabled(record.metadata()) {
+            eprintln!("{}", record.args())
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+pub const ABLEOS_PATH_RESOLVER: PathResolver =
+    &|mut path: &str, mut from: &str, tmp: &mut PathBuf| {
+        tmp.clear();
+
+        path = match path {
+            "stn" => {
+                from = "";
+                "./sysdata/libraries/stn/src/lib.hb"
+            }
+            _ => path,
+        };
+
+        match path.split_once(':') {
+            Some(("lib", p)) => tmp.extend(["./sysdata/libraries", p, "src/lib.hb"]),
+            Some(("stn", p)) => {
+                tmp.extend(["./sysdata/libraries/stn/src", &(p.to_owned() + ".hb")])
+            }
+            Some(("sysdata", p)) => tmp.extend(["./sysdata", p]),
+            None => match Path::new(from).parent() {
+                Some(parent) => tmp.extend([parent, Path::new(path)]),
+                None => tmp.push(path),
+            },
+            _ => panic!("path: '{path}' is invalid: unexpected ':'"),
+        };
+        tmp.canonicalize().map_err(|source| CantLoadFile { path: std::mem::take(tmp), source })
+    };
+
+#[derive(Default)]
+pub struct Options<'a> {
+    pub fmt: bool,
+    pub fmt_stdout: bool,
+    pub dump_asm: bool,
+    pub extra_threads: usize,
+    pub resolver: Option<PathResolver<'a>>,
+    pub backend: Option<&'a mut dyn Backend>,
+}
+
+pub fn run_compiler(
+    root_file: &str,
+    options: Options,
+    out: &mut Vec<u8>,
+    warnings: &mut String,
+) -> std::io::Result<()> {
+    let parsed = parse_from_fs(
+        options.extra_threads,
+        root_file,
+        options.resolver.unwrap_or(&default_resolve),
+    )?;
+
+    if (options.fmt || options.fmt_stdout) && !parsed.errors.is_empty() {
+        *out = parsed.errors.into_bytes();
+        return Err(std::io::Error::other("fmt fialed (errors are in out)"));
+    }
+
+    if options.fmt {
+        let mut output = String::new();
+        for ast in parsed.ast {
+            write!(output, "{ast}").unwrap();
+            if ast.file.deref().trim() != output.as_str().trim() {
+                std::fs::write(&*ast.path, &output)?;
+            }
+            output.clear();
+        }
+    } else if options.fmt_stdout {
+        write!(out, "{}", &parsed.ast[0])?;
+    } else {
+        let mut backend = HbvmBackend::default();
+        let backend = options.backend.unwrap_or(&mut backend);
+
+        let mut ctx = crate::son::CodegenCtx::default();
+        *ctx.parser.errors.get_mut() = parsed.errors;
+        let mut codegen = son::Codegen::new(backend, &parsed.ast, &mut ctx);
+        codegen.push_embeds(parsed.embeds);
+        codegen.generate(ty::Module::MAIN);
+
+        *warnings = core::mem::take(&mut *codegen.warnings.borrow_mut());
+
+        if !codegen.errors.borrow().is_empty() {
+            drop(codegen);
+            *out = ctx.parser.errors.into_inner().into_bytes();
+            return Err(std::io::Error::other("compilation faoled (errors are in out)"));
+        }
+
+        codegen.assemble(out);
+
+        if options.dump_asm {
+            let mut disasm = String::new();
+            let err = codegen.disasm(&mut disasm, out).map_err(|e| io::Error::other(e.to_string()));
+            *out = disasm.into_bytes();
+            err?
+        }
+    }
+
+    Ok(())
+}
+
+struct TaskQueue<T> {
+    inner: Mutex<TaskQueueInner<T>>,
+}
+
+impl<T> TaskQueue<T> {
+    fn new(max_waiters: usize) -> Self {
+        Self { inner: Mutex::new(TaskQueueInner::new(max_waiters)) }
+    }
+
+    pub fn push(&self, message: T) {
+        self.extend([message]);
+    }
+
+    pub fn extend(&self, messages: impl IntoIterator<Item = T>) {
+        self.inner.lock().unwrap().push(messages);
+    }
+
+    pub fn pop(&self) -> Option<T> {
+        TaskQueueInner::pop(&self.inner)
+    }
+}
+
+enum TaskSlot<T> {
+    Waiting,
+    Delivered(T),
+    Closed,
+}
+
+struct TaskQueueInner<T> {
+    max_waiters: usize,
+    messages: VecDeque<T>,
+    parked: VecDeque<(*mut TaskSlot<T>, std::thread::Thread)>,
+}
+
+unsafe impl<T: Send> Send for TaskQueueInner<T> {}
+unsafe impl<T: Send + Sync> Sync for TaskQueueInner<T> {}
+
+impl<T> TaskQueueInner<T> {
+    fn new(max_waiters: usize) -> Self {
+        Self { max_waiters, messages: Default::default(), parked: Default::default() }
+    }
+
+    fn push(&mut self, messages: impl IntoIterator<Item = T>) {
+        for msg in messages {
+            if let Some((dest, thread)) = self.parked.pop_front() {
+                unsafe { *dest = TaskSlot::Delivered(msg) };
+                thread.unpark();
+            } else {
+                self.messages.push_back(msg);
+            }
+        }
+    }
+
+    fn pop(s: &Mutex<Self>) -> Option<T> {
+        let mut res = TaskSlot::Waiting;
+        {
+            let mut s = s.lock().unwrap();
+            if let Some(msg) = s.messages.pop_front() {
+                return Some(msg);
+            }
+
+            if s.max_waiters == s.parked.len() + 1 {
+                for (dest, thread) in s.parked.drain(..) {
+                    unsafe { *dest = TaskSlot::Closed };
+                    thread.unpark();
+                }
+                return None;
+            }
+
+            s.parked.push_back((&mut res, std::thread::current()));
+        }
+
+        loop {
+            std::thread::park();
+
+            let _s = s.lock().unwrap();
+            match core::mem::replace(&mut res, TaskSlot::Waiting) {
+                TaskSlot::Delivered(msg) => return Some(msg),
+                TaskSlot::Closed => return None,
+                TaskSlot::Waiting => {}
+            }
+        }
+    }
+}
+
+pub struct Loaded {
+    ast: Vec<Ast>,
+    embeds: Vec<Vec<u8>>,
+    errors: String,
+}
+
+fn default_resolve(path: &str, from: &str, tmp: &mut PathBuf) -> Result<PathBuf, CantLoadFile> {
+    tmp.clear();
+    match Path::new(from).parent() {
+        Some(parent) => tmp.extend([parent, Path::new(path)]),
+        None => tmp.push(path),
+    };
+
+    tmp.canonicalize().map_err(|source| CantLoadFile { path: std::mem::take(tmp), source })
+}
+
+/// fn(path, from, tmp)
+pub type PathResolver<'a> =
+    &'a (dyn Fn(&str, &str, &mut PathBuf) -> Result<PathBuf, CantLoadFile> + Send + Sync);
+
+#[derive(Debug)]
+pub struct CantLoadFile {
+    pub path: PathBuf,
+    pub source: io::Error,
+}
+
+impl core::fmt::Display for CantLoadFile {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "can't load file: {}", crate::display_rel_path(&self.path),)
+    }
+}
+
+impl core::error::Error for CantLoadFile {
+    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
+        Some(&self.source)
+    }
+}
+
+impl From<CantLoadFile> for io::Error {
+    fn from(e: CantLoadFile) -> Self {
+        io::Error::new(io::ErrorKind::InvalidData, e)
+    }
+}
+
+pub fn parse_from_fs(
+    extra_threads: usize,
+    root: &str,
+    resolve: PathResolver,
+) -> io::Result<Loaded> {
+    type Task = (usize, PathBuf);
+
+    let seen_modules = Mutex::new(HashMap::<PathBuf, usize>::default());
+    let seen_embeds = Mutex::new(HashMap::<PathBuf, usize>::default());
+    let tasks = TaskQueue::<Task>::new(extra_threads + 1);
+    let ast = Mutex::new(Vec::<io::Result<Ast>>::new());
+    let embeds = Mutex::new(Vec::<Vec<u8>>::new());
+
+    let loader = |path: &str, from: &str, kind: FileKind, tmp: &mut _| {
+        let mut physiscal_path = resolve(path, from, tmp)?;
+
+        match kind {
+            FileKind::Module => {
+                let id = {
+                    let mut seen = seen_modules.lock().unwrap();
+                    let len = seen.len();
+                    match seen.entry(physiscal_path) {
+                        hash_map::Entry::Occupied(entry) => {
+                            return Ok(*entry.get());
+                        }
+                        hash_map::Entry::Vacant(entry) => {
+                            physiscal_path = entry.insert_entry(len as _).key().clone();
+                            len
+                        }
+                    }
+                };
+
+                if !physiscal_path.exists() {
+                    return Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("can't find file: {}", crate::display_rel_path(&physiscal_path)),
+                    ));
+                }
+
+                tasks.push((id, physiscal_path));
+                Ok(id)
+            }
+            FileKind::Embed => {
+                let id = {
+                    let mut seen = seen_embeds.lock().unwrap();
+                    let len = seen.len();
+                    match seen.entry(physiscal_path) {
+                        hash_map::Entry::Occupied(entry) => {
+                            return Ok(*entry.get());
+                        }
+                        hash_map::Entry::Vacant(entry) => {
+                            physiscal_path = entry.insert_entry(len as _).key().clone();
+                            len
+                        }
+                    }
+                };
+
+                let content = std::fs::read(&physiscal_path).map_err(|e| {
+                    io::Error::new(
+                        e.kind(),
+                        format!(
+                            "can't load embed file: {}: {e}",
+                            crate::display_rel_path(&physiscal_path)
+                        ),
+                    )
+                })?;
+                let mut embeds = embeds.lock().unwrap();
+                if id >= embeds.len() {
+                    embeds.resize(id + 1, Default::default());
+                }
+                embeds[id] = content;
+                Ok(id)
+            }
+        }
+    };
+
+    let execute_task = |ctx: &mut _, (_, path): Task, tmp: &mut _| {
+        let path = path.to_str().ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                format!("path contains invalid characters: {}", crate::display_rel_path(&path)),
+            )
+        })?;
+        Ok(Ast::new(path, std::fs::read_to_string(path)?, ctx, &mut |path, from, kind| {
+            loader(path, from, kind, tmp).map_err(|e| e.to_string())
+        }))
+    };
+
+    let thread = || {
+        let mut ctx = Ctx::default();
+        let mut tmp = PathBuf::new();
+        while let Some(task @ (indx, ..)) = tasks.pop() {
+            let res = execute_task(&mut ctx, task, &mut tmp);
+            let mut ast = ast.lock().unwrap();
+            let len = ast.len().max(indx + 1);
+            ast.resize_with(len, || Err(io::ErrorKind::InvalidData.into()));
+            ast[indx] = res;
+        }
+        ctx.errors.into_inner()
+    };
+
+    let path = Path::new(root).canonicalize().map_err(|e| {
+        io::Error::new(e.kind(), format!("can't canonicalize root file path ({root})"))
+    })?;
+    seen_modules.lock().unwrap().insert(path.clone(), 0);
+    tasks.push((0, path));
+
+    let errors = if extra_threads == 0 {
+        thread()
+    } else {
+        std::thread::scope(|s| {
+            (0..extra_threads + 1)
+                .map(|_| s.spawn(thread))
+                .collect::<Vec<_>>()
+                .into_iter()
+                .map(|t| t.join().unwrap())
+                .collect::<String>()
+        })
+    };
+
+    Ok(Loaded {
+        ast: ast.into_inner().unwrap().into_iter().collect::<io::Result<Vec<_>>>()?,
+        embeds: embeds.into_inner().unwrap(),
+        errors,
+    })
+}

lang/src/fuzz.rs

@@ -0,0 +1,142 @@
+use {
+    crate::{
+        backend::hbvm::HbvmBackend,
+        lexer::TokenKind,
+        parser,
+        son::{Codegen, CodegenCtx},
+        ty::Module,
+    },
+    alloc::string::String,
+    core::{fmt::Write, hash::BuildHasher, ops::Range},
+};
+
+#[derive(Default)]
+struct Rand(pub u64);
+
+impl Rand {
+    pub fn next(&mut self) -> u64 {
+        self.0 = crate::FnvBuildHasher::default().hash_one(self.0);
+        self.0
+    }
+
+    pub fn range(&mut self, min: u64, max: u64) -> u64 {
+        self.next() % (max - min) + min
+    }
+
+    fn bool(&mut self) -> bool {
+        self.next() % 2 == 0
+    }
+}
+
+#[derive(Default)]
+struct FuncGen {
+    rand: Rand,
+    buf: String,
+    vars: u64,
+}
+
+impl FuncGen {
+    fn gen(&mut self, seed: u64) -> &str {
+        self.rand = Rand(seed);
+        self.buf.clear();
+        self.buf.push_str("main := fn(): void ");
+        self.block().unwrap();
+        &self.buf
+    }
+
+    fn block(&mut self) -> core::fmt::Result {
+        let prev_vars = self.vars;
+        self.buf.push('{');
+        for _ in 0..self.rand.range(1, 10) {
+            self.stmt()?;
+        }
+        self.buf.push('}');
+        self.vars = prev_vars;
+
+        Ok(())
+    }
+
+    fn stmt(&mut self) -> core::fmt::Result {
+        match self.rand.range(0, 100) {
+            0..4 => _ = self.block(),
+            4..10 => {
+                write!(self.buf, "var{} := ", self.vars)?;
+                self.expr()?;
+                self.vars += 1;
+            }
+
+            10..20 if self.vars != 0 => {
+                write!(self.buf, "var{} = ", self.rand.range(0, self.vars))?;
+                self.expr()?;
+            }
+            20..23 => {
+                self.buf.push_str("if ");
+                self.expr()?;
+                self.block()?;
+                if self.rand.bool() {
+                    self.buf.push_str(" else ");
+                    self.block()?;
+                }
+            }
+            _ => {
+                self.buf.push_str("return ");
+                self.expr()?;
+            }
+        }
+
+        self.buf.push(';');
+        Ok(())
+    }
+
+    fn expr(&mut self) -> core::fmt::Result {
+        match self.rand.range(0, 100) {
+            0..80 => {
+                write!(self.buf, "{}", self.rand.next())
+            }
+            80..90 if self.vars != 0 => {
+                write!(self.buf, "var{}", self.rand.range(0, self.vars))
+            }
+            80..100 => {
+                self.expr()?;
+                let ops = [
+                    TokenKind::Add,
+                    TokenKind::Sub,
+                    TokenKind::Mul,
+                    TokenKind::Div,
+                    TokenKind::Shl,
+                    TokenKind::Eq,
+                    TokenKind::Ne,
+                    TokenKind::Lt,
+                    TokenKind::Gt,
+                    TokenKind::Le,
+                    TokenKind::Ge,
+                    TokenKind::Band,
+                    TokenKind::Bor,
+                    TokenKind::Xor,
+                    TokenKind::Mod,
+                    TokenKind::Shr,
+                ];
+                let op = ops[self.rand.range(0, ops.len() as u64) as usize];
+                write!(self.buf, " {op} ")?;
+                self.expr()
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+pub fn fuzz(seed_range: Range<u64>) {
+    let mut gen = FuncGen::default();
+    let mut ctx = CodegenCtx::default();
+    for i in seed_range {
+        ctx.clear();
+        let src = gen.gen(i);
+        let parsed = parser::Ast::new("fuzz", src, &mut ctx.parser, &mut parser::no_loader);
+
+        assert!(ctx.parser.errors.get_mut().is_empty());
+
+        let mut backend = HbvmBackend::default();
+        let mut cdg = Codegen::new(&mut backend, core::slice::from_ref(&parsed), &mut ctx);
+        cdg.generate(Module::MAIN);
+    }
+}

lang/src/fuzz_main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    hblang::fuzz::fuzz(0..1000000);
+}

lang/src/lexer.rs

@@ -1,5 +1,3 @@
-use crate::{instrs, EncodedInstr};
-
 const fn ascii_mask(chars: &[u8]) -> u128 {
     let mut eq = 0;
     let mut i = 0;
@@ -19,7 +17,7 @@ pub struct Token {
 }
 
 impl Token {
-    pub fn range(&self) -> std::ops::Range<usize> {
+    pub fn range(&self) -> core::ops::Range<usize> {
         self.start as usize..self.end as usize
     }
 }
@@ -34,6 +32,9 @@ macro_rules! gen_token_kind {
             #[keywords] $(
                 $keyword:ident = $keyword_lit:literal,
             )*
+            #[const_keywords] $(
+                $const_keyword:ident = $const_keyword_lit:literal,
+            )*
             #[punkt] $(
                 $punkt:ident = $punkt_lit:literal,
             )*
@@ -44,22 +45,25 @@ macro_rules! gen_token_kind {
             )*
         }
     ) => {
-        impl std::fmt::Display for $name {
-            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        impl core::fmt::Display for $name {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                 f.write_str(self.name())
             }
         }
 
         impl $name {
+            pub const OPS: &[Self] = &[$($(Self::$op),*),*];
+
             pub fn name(&self) -> &str {
                 let sf = unsafe { &*(self as *const _ as *const u8) } ;
                 match *self {
                     $( Self::$pattern => concat!('<', stringify!($pattern), '>'), )*
                     $( Self::$keyword => stringify!($keyword_lit), )*
+                    $( Self::$const_keyword => concat!('$', $const_keyword_lit), )*
                     $( Self::$punkt   => stringify!($punkt_lit),   )*
                     $($( Self::$op    => $op_lit,
                       $(Self::$assign => concat!($op_lit, "="),)?)*)*
-                    _ => unsafe { std::str::from_utf8_unchecked(std::slice::from_ref(&sf)) },
+                    _ => unsafe { core::str::from_utf8_unchecked(core::slice::from_ref(&sf)) },
                 }
             }
 
@@ -72,18 +76,28 @@ macro_rules! gen_token_kind {
                 } + 1)
             }
 
-            #[inline(always)]
+            #[allow(non_upper_case_globals)]
             fn from_ident(ident: &[u8]) -> Self {
+                $(const $keyword: &[u8] = $keyword_lit.as_bytes();)*
                 match ident {
-                    $($keyword_lit => Self::$keyword,)*
+                    $($keyword => Self::$keyword,)*
                     _ => Self::Ident,
                 }
             }
+
+            #[allow(non_upper_case_globals)]
+            fn from_ct_ident(ident: &[u8]) -> Self {
+                $(const $const_keyword: &[u8] = $const_keyword_lit.as_bytes();)*
+                match ident {
+                    $($const_keyword => Self::$const_keyword,)*
+                    _ => Self::CtIdent,
+                }
+            }
         }
     };
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord)]
+#[derive(PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum TokenKind {
     Not = b'!',
@@ -117,24 +131,16 @@ pub enum TokenKind {
 
     Ident,
     Number,
+    Float,
     Eof,
 
     Ct,
 
-    Return,
-    If,
-    Else,
-    Loop,
-    Break,
-    Continue,
-    Fn,
-    Struct,
-    True,
-    False,
-    Idk,
-
     Ctor,
     Tupl,
+    Arr,
+    TArrow,
+    Range,
 
     Or,
     And,
@@ -144,7 +150,31 @@ pub enum TokenKind {
     BSlash = b'\\',
     RBrack = b']',
     Xor = b'^',
+    Under = b'_',
     Tick = b'`',
+
+    Slf,
+    Return,
+    If,
+    Match,
+    Else,
+    Loop,
+    Break,
+    Continue,
+    Fn,
+    Struct,
+    Packed,
+    Enum,
+    Union,
+    True,
+    False,
+    Null,
+    Idk,
+    Die,
+    Defer,
+
+    CtLoop,
+
     // Unused = a-z
     LBrace = b'{',
     Bor = b'|',
@@ -169,93 +199,19 @@ pub enum TokenKind {
     ShlAss = b'<' - 5 + 128,
 }
 
+impl core::fmt::Debug for TokenKind {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(self, f)
+    }
+}
+
 impl TokenKind {
-    #[allow(clippy::type_complexity)]
-    pub fn cond_op(self, signed: bool) -> Option<(fn(u8, u8, i16) -> EncodedInstr, bool)> {
-        Some((
-            match self {
-                Self::Le if signed => instrs::jgts,
-                Self::Le => instrs::jgtu,
-                Self::Lt if signed => instrs::jlts,
-                Self::Lt => instrs::jltu,
-                Self::Ge if signed => instrs::jlts,
-                Self::Ge => instrs::jltu,
-                Self::Gt if signed => instrs::jgts,
-                Self::Gt => instrs::jgtu,
-                Self::Eq => instrs::jne,
-                Self::Ne => instrs::jeq,
-                _ => return None,
-            },
-            matches!(self, Self::Lt | TokenKind::Gt),
-        ))
-    }
-
-    pub fn binop(self, signed: bool, size: u32) -> Option<fn(u8, u8, u8) -> EncodedInstr> {
-        use instrs::*;
-
-        macro_rules! div { ($($op:ident),*) => {[$(|a, b, c| $op(a, 0, b, c)),*]}; }
-        macro_rules! rem { ($($op:ident),*) => {[$(|a, b, c| $op(0, a, b, c)),*]}; }
-
-        let ops = match self {
-            Self::Add => [add8, add16, add32, add64],
-            Self::Sub => [sub8, sub16, sub32, sub64],
-            Self::Mul => [mul8, mul16, mul32, mul64],
-            Self::Div if signed => div!(dirs8, dirs16, dirs32, dirs64),
-            Self::Div => div!(diru8, diru16, diru32, diru64),
-            Self::Mod if signed => rem!(dirs8, dirs16, dirs32, dirs64),
-            Self::Mod => rem!(diru8, diru16, diru32, diru64),
-            Self::Band => return Some(and),
-            Self::Bor => return Some(or),
-            Self::Xor => return Some(xor),
-            Self::Shl => [slu8, slu16, slu32, slu64],
-            Self::Shr if signed => [srs8, srs16, srs32, srs64],
-            Self::Shr => [sru8, sru16, sru32, sru64],
-            _ => return None,
-        };
-
-        Some(ops[size.ilog2() as usize])
-    }
-
-    #[allow(clippy::type_complexity)]
-    pub fn imm_binop(self, signed: bool, size: u32) -> Option<fn(u8, u8, u64) -> EncodedInstr> {
-        use instrs::*;
-        macro_rules! def_op {
-            ($name:ident |$a:ident, $b:ident, $c:ident| $($tt:tt)*) => {
-                macro_rules! $name {
-                    ($$($$op:ident),*) => {
-                        [$$(
-                            |$a, $b, $c: u64| $$op($($tt)*),
-                        )*]
-                    }
-                }
-            };
-        }
-
-        def_op!(basic_op | a, b, c | a, b, c as _);
-        def_op!(sub_op | a, b, c | a, b, c.wrapping_neg() as _);
-
-        let ops = match self {
-            Self::Add => basic_op!(addi8, addi16, addi32, addi64),
-            Self::Sub => sub_op!(addi8, addi16, addi32, addi64),
-            Self::Mul => basic_op!(muli8, muli16, muli32, muli64),
-            Self::Band => return Some(andi),
-            Self::Bor => return Some(ori),
-            Self::Xor => return Some(xori),
-            Self::Shr if signed => basic_op!(srui8, srui16, srui32, srui64),
-            Self::Shr => basic_op!(srui8, srui16, srui32, srui64),
-            Self::Shl => basic_op!(slui8, slui16, slui32, slui64),
-            _ => return None,
-        };
-
-        Some(ops[size.ilog2() as usize])
-    }
-
     pub fn ass_op(self) -> Option<Self> {
         let id = (self as u8).saturating_sub(128);
         if ascii_mask(b"|+-*/%^&79") & (1u128 << id) == 0 {
             return None;
         }
-        Some(unsafe { std::mem::transmute::<u8, Self>(id) })
+        Some(unsafe { core::mem::transmute::<u8, Self>(id) })
     }
 
     pub fn is_comutative(self) -> bool {
@@ -263,15 +219,66 @@ impl TokenKind {
         matches!(self, S::Eq | S::Ne | S::Bor | S::Xor | S::Band | S::Add | S::Mul)
     }
 
-    pub fn apply_binop(self, a: i64, b: i64) -> i64 {
+    pub fn is_compatison(self) -> bool {
+        matches!(self, Self::Lt | Self::Gt | Self::Ge | Self::Le | Self::Ne | Self::Eq)
+    }
+
+    pub fn is_supported_float_op(self) -> bool {
+        matches!(
+            self,
+            Self::Add
+                | Self::Sub
+                | Self::Mul
+                | Self::Div
+                | Self::Eq
+                | Self::Ne
+                | Self::Le
+                | Self::Ge
+                | Self::Lt
+                | Self::Gt
+        )
+    }
+
+    pub fn apply_binop(self, a: i64, b: i64, float: bool) -> i64 {
+        if float {
+            debug_assert!(self.is_supported_float_op());
+            let [a, b] = [f64::from_bits(a as _), f64::from_bits(b as _)];
+            let res = match self {
+                Self::Add => a + b,
+                Self::Sub => a - b,
+                Self::Mul => a * b,
+                Self::Div => a / b,
+                Self::Eq => return (a == b) as i64,
+                Self::Ne => return (a != b) as i64,
+                Self::Lt => return (a < b) as i64,
+                Self::Gt => return (a > b) as i64,
+                Self::Le => return (a >= b) as i64,
+                Self::Ge => return (a <= b) as i64,
+                _ => todo!("floating point op: {self}"),
+            };
+
+            return res.to_bits() as _;
+        }
+
         match self {
             Self::Add => a.wrapping_add(b),
             Self::Sub => a.wrapping_sub(b),
             Self::Mul => a.wrapping_mul(b),
+            Self::Div if b == 0 => 0,
             Self::Div => a.wrapping_div(b),
             Self::Shl => a.wrapping_shl(b as _),
             Self::Eq => (a == b) as i64,
+            Self::Ne => (a != b) as i64,
+            Self::Lt => (a < b) as i64,
+            Self::Gt => (a > b) as i64,
+            Self::Le => (a >= b) as i64,
+            Self::Ge => (a <= b) as i64,
             Self::Band => a & b,
+            Self::Bor => a | b,
+            Self::Xor => a ^ b,
+            Self::Mod if b == 0 => 0,
+            Self::Mod => a.wrapping_rem(b),
+            Self::Shr => a.wrapping_shr(b as _),
             s => todo!("{s}"),
         }
     }
@@ -282,19 +289,29 @@ impl TokenKind {
             && self.precedence() != Self::Eof.precedence()
     }
 
-    pub fn unop(&self) -> Option<fn(u8, u8) -> EncodedInstr> {
-        Some(match self {
-            Self::Sub => instrs::neg,
-            _ => return None,
-        })
-    }
-
-    pub fn apply_unop(&self, value: i64) -> i64 {
+    pub fn apply_unop(&self, value: i64, float: bool) -> i64 {
         match self {
+            Self::Sub if float => (-f64::from_bits(value as _)).to_bits() as _,
             Self::Sub => value.wrapping_neg(),
+            Self::Not => (value == 0) as _,
+            Self::Float if float => value,
+            Self::Float => (value as f64).to_bits() as _,
+            Self::Number if float => f64::from_bits(value as _) as _,
+            Self::Number => value,
             s => todo!("{s}"),
         }
     }
+
+    pub fn closing(&self) -> Option<TokenKind> {
+        Some(match self {
+            Self::Ctor => Self::RBrace,
+            Self::Tupl => Self::RParen,
+            Self::LParen => Self::RParen,
+            Self::LBrack => Self::RBrack,
+            Self::LBrace => Self::RBrace,
+            _ => return None,
+        })
+    }
 }
 
 gen_token_kind! {
@@ -303,23 +320,38 @@ gen_token_kind! {
         CtIdent,
         Ident,
         Number,
+        Float,
         Eof,
         Directive,
         #[keywords]
-        Return    = b"return",
-        If        = b"if",
-        Else      = b"else",
-        Loop      = b"loop",
-        Break     = b"break",
-        Continue  = b"continue",
-        Fn        = b"fn",
-        Struct    = b"struct",
-        True      = b"true",
-        False     = b"false",
-        Idk = b"idk",
+        Slf       = "Self",
+        Return    = "return",
+        If        = "if",
+        Match     = "match",
+        Else      = "else",
+        Loop      = "loop",
+        Break     = "break",
+        Continue  = "continue",
+        Fn        = "fn",
+        Struct    = "struct",
+        Packed    = "packed",
+        Enum      = "enum",
+        Union     = "union",
+        True      = "true",
+        False     = "false",
+        Null      = "null",
+        Idk       = "idk",
+        Die       = "die",
+        Defer     = "defer",
+        Under     = "_",
+        #[const_keywords]
+        CtLoop = "loop",
         #[punkt]
         Ctor   = ".{",
         Tupl   = ".(",
+        Arr    = ".[",
+        TArrow = "=>",
+        Range  = "..",
         // #define OP: each `#[prec]` delimeters a level of precedence from lowest to highest
         #[ops]
         #[prec]
@@ -359,7 +391,7 @@ gen_token_kind! {
 
 pub struct Lexer<'a> {
     pos: u32,
-    bytes: &'a [u8],
+    source: &'a [u8],
 }
 
 impl<'a> Lexer<'a> {
@@ -367,23 +399,59 @@ impl<'a> Lexer<'a> {
         Self::restore(input, 0)
     }
 
+    pub fn uses(input: &'a str) -> impl Iterator<Item = &'a str> {
+        let mut s = Self::new(input);
+        core::iter::from_fn(move || loop {
+            let t = s.eat();
+            if t.kind == TokenKind::Eof {
+                return None;
+            }
+            if t.kind == TokenKind::Directive
+                && s.slice(t.range()) == "use"
+                && s.eat().kind == TokenKind::LParen
+            {
+                let t = s.eat();
+                if t.kind == TokenKind::DQuote {
+                    return Some(&s.slice(t.range())[1..t.range().len() - 1]);
+                }
+            }
+        })
+    }
+
     pub fn restore(input: &'a str, pos: u32) -> Self {
-        Self { pos, bytes: input.as_bytes() }
+        Self { pos, source: input.as_bytes() }
     }
 
     pub fn source(&self) -> &'a str {
-        unsafe { std::str::from_utf8_unchecked(self.bytes) }
+        unsafe { core::str::from_utf8_unchecked(self.source) }
     }
 
-    pub fn slice(&self, tok: std::ops::Range<usize>) -> &'a str {
-        unsafe { std::str::from_utf8_unchecked(&self.bytes[tok]) }
+    pub fn slice(&self, tok: core::ops::Range<usize>) -> &'a str {
+        unsafe { core::str::from_utf8_unchecked(&self.source[tok]) }
+    }
+
+    pub fn taste(&self) -> Token {
+        Lexer { pos: self.pos, source: self.source }.eat()
+    }
+
+    fn peek_n<const N: usize>(&self) -> Option<&[u8; N]> {
+        if core::intrinsics::unlikely(self.pos as usize + N > self.source.len()) {
+            None
+        } else {
+            Some(unsafe {
+                self.source
+                    .get_unchecked(self.pos as usize..self.pos as usize + N)
+                    .first_chunk()
+                    .unwrap_unchecked()
+            })
+        }
     }
 
     fn peek(&self) -> Option<u8> {
-        if std::intrinsics::unlikely(self.pos >= self.bytes.len() as u32) {
+        if core::intrinsics::unlikely(self.pos >= self.source.len() as u32) {
             None
         } else {
-            Some(unsafe { *self.bytes.get_unchecked(self.pos as usize) })
+            Some(unsafe { *self.source.get_unchecked(self.pos as usize) })
         }
     }
 
@@ -394,9 +462,9 @@ impl<'a> Lexer<'a> {
     }
 
     pub fn last(&mut self) -> Token {
-        let mut token = self.next();
+        let mut token = self.eat();
         loop {
-            let next = self.next();
+            let next = self.eat();
             if next.kind == TokenKind::Eof {
                 break;
             }
@@ -405,7 +473,7 @@ impl<'a> Lexer<'a> {
         token
     }
 
-    pub fn next(&mut self) -> Token {
+    pub fn eat(&mut self) -> Token {
         use TokenKind as T;
         loop {
             let mut start = self.pos;
@@ -420,7 +488,7 @@ impl<'a> Lexer<'a> {
                 }
             };
 
-            let identity = |s: u8| unsafe { std::mem::transmute::<u8, T>(s) };
+            let identity = |s: u8| unsafe { core::mem::transmute::<u8, T>(s) };
 
             let kind = match c {
                 ..=b' ' => continue,
@@ -446,11 +514,23 @@ impl<'a> Lexer<'a> {
                     while let Some(b'0'..=b'9') = self.peek() {
                         self.advance();
                     }
-                    T::Number
+
+                    if self
+                        .peek_n()
+                        .map_or_else(|| self.peek() == Some(b'.'), |&[a, b]| a == b'.' && b != b'.')
+                    {
+                        self.pos += 1;
+                        while let Some(b'0'..=b'9') = self.peek() {
+                            self.advance();
+                        }
+                        T::Float
+                    } else {
+                        T::Number
+                    }
                 }
                 b'a'..=b'z' | b'A'..=b'Z' | b'_' | 127.. => {
                     advance_ident(self);
-                    let ident = &self.bytes[start as usize..self.pos as usize];
+                    let ident = &self.source[start as usize..self.pos as usize];
                     T::from_ident(ident)
                 }
                 b'"' | b'\'' => loop {
@@ -462,10 +542,18 @@ impl<'a> Lexer<'a> {
                     }
                 },
                 b'/' if self.advance_if(b'/') => {
-                    while let Some(l) = self.advance()
+                    while let Some(l) = self.peek()
                         && l != b'\n'
-                    {}
-                    T::Comment
+                    {
+                        self.pos += 1;
+                    }
+
+                    let end = self.source[..self.pos as usize]
+                        .iter()
+                        .rposition(|&b| !b.is_ascii_whitespace())
+                        .map_or(self.pos, |i| i as u32 + 1);
+
+                    return Token { kind: T::Comment, start, end };
                 }
                 b'/' if self.advance_if(b'*') => {
                     let mut depth = 1;
@@ -483,14 +571,23 @@ impl<'a> Lexer<'a> {
                 }
                 b'.' if self.advance_if(b'{') => T::Ctor,
                 b'.' if self.advance_if(b'(') => T::Tupl,
+                b'.' if self.advance_if(b'[') => T::Arr,
+                b'.' if self.advance_if(b'.') => T::Range,
+                b'=' if self.advance_if(b'>') => T::TArrow,
                 b'&' if self.advance_if(b'&') => T::And,
                 b'|' if self.advance_if(b'|') => T::Or,
                 b'$' if self.advance_if(b':') => T::Ct,
-                b'@' | b'$' => {
+                b'@' => {
                     start += 1;
                     advance_ident(self);
                     identity(c)
                 }
+                b'$' => {
+                    start += 1;
+                    advance_ident(self);
+                    let ident = &self.source[start as usize..self.pos as usize];
+                    T::from_ct_ident(ident)
+                }
                 b'<' | b'>' if self.advance_if(c) => {
                     identity(c - 5 + 128 * self.advance_if(b'=') as u8)
                 }

lang/src/lib.rs

@@ -0,0 +1,609 @@
+#![feature(
+    iter_array_chunks,
+    str_split_remainder,
+    assert_matches,
+    let_chains,
+    if_let_guard,
+    macro_metavar_expr,
+    anonymous_lifetime_in_impl_trait,
+    core_intrinsics,
+    never_type,
+    unwrap_infallible,
+    slice_partition_dedup,
+    portable_simd,
+    iter_collect_into,
+    ptr_metadata,
+    slice_ptr_get,
+    slice_take,
+    map_try_insert,
+    extract_if,
+    ptr_internals,
+    iter_intersperse,
+    str_from_raw_parts,
+    ptr_sub_ptr,
+    slice_from_ptr_range,
+    iter_next_chunk,
+    pointer_is_aligned_to,
+    maybe_uninit_fill,
+    array_chunks,
+    array_windows
+)]
+#![warn(clippy::dbg_macro)]
+#![expect(internal_features)]
+#![no_std]
+
+#[cfg(feature = "std")]
+pub use fs::*;
+use {
+    self::{ty::Builtin, utils::Ent},
+    alloc::vec::Vec,
+    core::{fmt::Arguments, format_args as fa},
+};
+
+#[macro_use]
+extern crate alloc;
+
+#[cfg(any(feature = "std", test))]
+extern crate std;
+
+#[cfg(test)]
+#[macro_export]
+macro_rules! run_tests {
+    ($runner:path: $($name:ident;)*) => {$(
+        #[test]
+        fn $name() {
+            $crate::run_test(core::any::type_name_of_val(&$name), stringify!($name), $crate::README, $runner);
+        }
+    )*};
+}
+
+pub mod fmt;
+#[cfg(any(feature = "std", test))]
+pub mod fs;
+pub mod fuzz;
+pub mod lexer;
+pub mod nodes;
+pub mod parser;
+pub mod son;
+pub mod ty;
+
+pub mod backend {
+    use {
+        crate::{
+            nodes::Nodes,
+            parser,
+            ty::{self, Module, Types},
+            utils::EntSlice,
+        },
+        alloc::{string::String, vec::Vec},
+        core::{error, mem::take},
+    };
+
+    pub fn match_triple(pattern: &str, triple: &str) -> Result<bool, &'static str> {
+        if pattern == "*" {
+            return Err("you can replace this with 'true'");
+        }
+
+        if pattern.ends_with("-*") {
+            return Err("trailing '*' is redundant");
+        }
+
+        let mut matcher = pattern.split('-');
+        let mut matchee = triple.split('-');
+        let mut eat_start = false;
+        loop {
+            match matcher.next() {
+                Some("*") if eat_start => return Err("consecutive '*' are redundant"),
+                Some("*") if matchee.next().is_none() => return Ok(false),
+                Some("*") => eat_start = true,
+                Some(pat) if take(&mut eat_start) => {
+                    if matchee.by_ref().all(|v| v != pat) {
+                        return Ok(false);
+                    }
+                }
+                Some(pat) if matchee.next() != Some(pat) => return Ok(false),
+                Some(_) => {}
+                None => return Ok(true),
+            }
+        }
+    }
+
+    #[test]
+    fn sanity_match_triple() {
+        assert!(match_triple("a-b-c", "a-b-c").unwrap());
+        assert!(match_triple("*-b-c", "a-b-c").unwrap());
+        assert!(match_triple("*-c", "a-b-c").unwrap());
+        assert!(match_triple("a", "a-b-c").unwrap());
+
+        assert!(!match_triple("*-a", "a-b-c").unwrap());
+        assert!(!match_triple("*-a", "a-b-c").unwrap());
+        assert!(match_triple("*-*", "a-b-c").is_err());
+        assert!(match_triple("*-b-*", "a-b-c").is_err());
+    }
+
+    pub mod hbvm;
+
+    pub struct AssemblySpec {
+        pub entry: u32,
+        pub code_length: u64,
+        pub data_length: u64,
+    }
+
+    pub trait Backend {
+        fn triple(&self) -> String;
+        fn assemble_reachable(
+            &mut self,
+            from: ty::Func,
+            types: &Types,
+            files: &EntSlice<Module, parser::Ast>,
+            to: &mut Vec<u8>,
+        ) -> AssemblySpec;
+        fn disasm<'a>(
+            &'a self,
+            sluce: &[u8],
+            eca_handler: &mut dyn FnMut(&mut &[u8]),
+            types: &'a Types,
+            files: &'a EntSlice<Module, parser::Ast>,
+            output: &mut String,
+        ) -> Result<(), alloc::boxed::Box<dyn error::Error + Send + Sync + 'a>>;
+        fn emit_body(
+            &mut self,
+            id: ty::Func,
+            nodes: &Nodes,
+            tys: &Types,
+            files: &EntSlice<Module, parser::Ast>,
+        );
+
+        fn emit_ct_body(
+            &mut self,
+            id: ty::Func,
+            nodes: &Nodes,
+            tys: &Types,
+            files: &EntSlice<Module, parser::Ast>,
+        ) {
+            self.emit_body(id, nodes, tys, files);
+        }
+
+        fn assemble_bin(
+            &mut self,
+            from: ty::Func,
+            types: &Types,
+            files: &EntSlice<Module, parser::Ast>,
+            to: &mut Vec<u8>,
+        ) {
+            self.assemble_reachable(from, types, files, to);
+        }
+    }
+}
+
+pub mod utils;
+
+mod debug {
+    use core::fmt::Debug;
+
+    pub fn panicking() -> bool {
+        #[cfg(feature = "std")]
+        {
+            std::thread::panicking()
+        }
+        #[cfg(not(feature = "std"))]
+        {
+            false
+        }
+    }
+
+    #[cfg(all(debug_assertions, feature = "std"))]
+    pub type Trace = std::rc::Rc<(std::backtrace::Backtrace, std::string::String)>;
+    #[cfg(not(all(debug_assertions, feature = "std")))]
+    pub type Trace = ();
+
+    pub fn trace(_hint: impl Debug) -> Trace {
+        #[cfg(all(debug_assertions, feature = "std"))]
+        {
+            std::rc::Rc::new((std::backtrace::Backtrace::capture(), format!("{_hint:?}")))
+        }
+        #[cfg(not(all(debug_assertions, feature = "std")))]
+        {}
+    }
+}
+
+mod ctx_map {
+    use core::hash::BuildHasher;
+
+    pub type Hash = u64;
+    pub type HashBuilder = core::hash::BuildHasherDefault<IdentityHasher>;
+
+    #[derive(Default)]
+    pub struct IdentityHasher(u64);
+
+    impl core::hash::Hasher for IdentityHasher {
+        fn finish(&self) -> u64 {
+            self.0
+        }
+
+        fn write(&mut self, _: &[u8]) {
+            unimplemented!()
+        }
+
+        fn write_u64(&mut self, i: u64) {
+            self.0 = i;
+        }
+    }
+
+    #[derive(Clone)]
+    pub struct Key<T> {
+        pub value: T,
+        pub hash: Hash,
+    }
+
+    impl<T> core::hash::Hash for Key<T> {
+        fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+            state.write_u64(self.hash);
+        }
+    }
+
+    pub trait CtxEntry {
+        type Ctx: ?Sized;
+        type Key<'a>: Eq + core::hash::Hash;
+
+        fn key<'a>(&self, ctx: &'a Self::Ctx) -> Self::Key<'a>;
+    }
+
+    #[derive(Clone)]
+    pub struct CtxMap<T> {
+        inner: hashbrown::HashMap<Key<T>, (), HashBuilder>,
+    }
+
+    impl<T> Default for CtxMap<T> {
+        fn default() -> Self {
+            Self { inner: Default::default() }
+        }
+    }
+
+    impl<T: CtxEntry> CtxMap<T> {
+        pub fn entry<'a, 'b>(
+            &'a mut self,
+            key: T::Key<'b>,
+            ctx: &'b T::Ctx,
+        ) -> (hashbrown::hash_map::RawEntryMut<'a, Key<T>, (), HashBuilder>, Hash) {
+            let hash = crate::FnvBuildHasher::default().hash_one(&key);
+            (self.inner.raw_entry_mut().from_hash(hash, |k| k.value.key(ctx) == key), hash)
+        }
+
+        pub fn get<'a>(&self, key: T::Key<'a>, ctx: &'a T::Ctx) -> Option<&T> {
+            let hash = crate::FnvBuildHasher::default().hash_one(&key);
+            self.inner
+                .raw_entry()
+                .from_hash(hash, |k| k.value.key(ctx) == key)
+                .map(|(k, _)| &k.value)
+        }
+
+        pub fn clear(&mut self) {
+            self.inner.clear();
+        }
+
+        pub fn remove(&mut self, value: &T, ctx: &T::Ctx) -> Option<T> {
+            let (entry, _) = self.entry(value.key(ctx), ctx);
+            match entry {
+                hashbrown::hash_map::RawEntryMut::Occupied(o) => Some(o.remove_entry().0.value),
+                hashbrown::hash_map::RawEntryMut::Vacant(_) => None,
+            }
+        }
+
+        pub fn insert<'a>(&mut self, key: T::Key<'a>, value: T, ctx: &'a T::Ctx) {
+            let (entry, hash) = self.entry(key, ctx);
+            match entry {
+                hashbrown::hash_map::RawEntryMut::Occupied(_) => unreachable!(),
+                hashbrown::hash_map::RawEntryMut::Vacant(v) => {
+                    _ = v.insert(Key { hash, value }, ())
+                }
+            }
+        }
+
+        pub fn get_or_insert<'a>(
+            &mut self,
+            key: T::Key<'a>,
+            ctx: &'a mut T::Ctx,
+            with: impl FnOnce(&'a mut T::Ctx) -> T,
+        ) -> &mut T {
+            let (entry, hash) = self.entry(key, unsafe { &mut *(&mut *ctx as *mut _) });
+            match entry {
+                hashbrown::hash_map::RawEntryMut::Occupied(o) => &mut o.into_key_value().0.value,
+                hashbrown::hash_map::RawEntryMut::Vacant(v) => {
+                    &mut v.insert(Key { hash, value: with(ctx) }, ()).0.value
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
+pub struct Ident(u32);
+
+impl Ident {
+    pub const INVALID: Self = Self(u32::MAX);
+    const LEN_BITS: u32 = 6;
+
+    pub fn len(self) -> u32 {
+        self.0 & ((1 << Self::LEN_BITS) - 1)
+    }
+
+    pub fn is_type(self) -> bool {
+        ty::Builtin::try_from(self) == Ok(ty::Builtin::TYPE)
+    }
+
+    pub fn is_empty(self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn is_null(self) -> bool {
+        (self.0 >> Self::LEN_BITS) == 0
+    }
+
+    pub fn pos(self) -> u32 {
+        (self.0 >> Self::LEN_BITS).saturating_sub(1)
+    }
+
+    pub fn new(pos: u32, len: u32) -> Option<Self> {
+        (len < (1 << Self::LEN_BITS)).then_some(((pos + 1) << Self::LEN_BITS) | len).map(Self)
+    }
+
+    pub fn range(self) -> core::ops::Range<usize> {
+        let (len, pos) = (self.len() as usize, self.pos() as usize);
+        pos..pos + len
+    }
+
+    fn builtin(builtin: Builtin) -> Ident {
+        Self(builtin.index() as _)
+    }
+}
+
+fn endoce_string(
+    literal: &str,
+    str: &mut Vec<u8>,
+    report: impl Fn(&core::str::Bytes, Arguments),
+) -> Option<usize> {
+    let report = |bytes: &core::str::Bytes, msg: Arguments| {
+        report(bytes, msg);
+        None::<u8>
+    };
+
+    let decode_braces = |str: &mut Vec<u8>, bytes: &mut core::str::Bytes| {
+        while let Some(b) = bytes.next()
+            && b != b'}'
+        {
+            let c = bytes.next().or_else(|| report(bytes, fa!("incomplete escape sequence")))?;
+            let decode = |b: u8| {
+                Some(match b {
+                    b'0'..=b'9' => b - b'0',
+                    b'a'..=b'f' => b - b'a' + 10,
+                    b'A'..=b'F' => b - b'A' + 10,
+                    _ => report(bytes, fa!("expected hex digit or '}}'"))?,
+                })
+            };
+            str.push(decode(b)? << 4 | decode(c)?);
+        }
+
+        Some(())
+    };
+
+    let mut bytes = literal.bytes();
+    let mut char_len = 0;
+    while let Some(b) = bytes.next() {
+        char_len += 1;
+        if b != b'\\' {
+            str.push(b);
+            continue;
+        }
+
+        const SPECIAL_CHARS: &str = "nrt\\'\"0";
+        const TO_BYTES: &[u8] = b"\n\r\t\\'\"\0";
+        const _: () = assert!(SPECIAL_CHARS.len() == TO_BYTES.len());
+
+        let b = match bytes.next().or_else(|| report(&bytes, fa!("incomplete escape sequence")))? {
+            b if let Some((_, &i)) = SPECIAL_CHARS.bytes().zip(TO_BYTES).find(|&(i, _)| i == b) => {
+                i
+            }
+            b'{' => {
+                decode_braces(str, &mut bytes);
+                continue;
+            }
+            _ => report(
+                &bytes,
+                format_args!(
+                    "unknown escape sequence, \
+                    expected one of special characters (regex /[{SPECIAL_CHARS}]/), \
+                    or arbitrary byte sequence in hex (regex /\\{{[0-9a-f]{{2}}+\\/}})"
+                ),
+            )?,
+        };
+        str.push(b);
+    }
+
+    Some(char_len)
+}
+
+pub fn quad_sort<T>(mut slice: &mut [T], mut cmp: impl FnMut(&T, &T) -> core::cmp::Ordering) {
+    while let Some(it) = slice.take_first_mut() {
+        for ot in &mut *slice {
+            if cmp(it, ot) == core::cmp::Ordering::Greater {
+                core::mem::swap(it, ot);
+            }
+        }
+    }
+    debug_assert!(slice.is_sorted_by(|a, b| cmp(a, b) != core::cmp::Ordering::Greater));
+}
+
+type FnvBuildHasher = core::hash::BuildHasherDefault<FnvHasher>;
+
+struct FnvHasher(u64);
+
+impl core::hash::Hasher for FnvHasher {
+    fn finish(&self) -> u64 {
+        self.0
+    }
+
+    fn write(&mut self, bytes: &[u8]) {
+        self.0 = bytes.iter().fold(self.0, |hash, &byte| {
+            let mut hash = hash;
+            hash ^= byte as u64;
+            hash = hash.wrapping_mul(0x100000001B3);
+            hash
+        });
+    }
+}
+
+impl Default for FnvHasher {
+    fn default() -> Self {
+        Self(0xCBF29CE484222325)
+    }
+}
+
+#[cfg(test)]
+pub fn run_test(
+    name: &str,
+    ident: &str,
+    input: &str,
+    test: fn(&str, &str, &mut alloc::string::String),
+) {
+    use std::{
+        io::Write,
+        path::PathBuf,
+        string::{String, ToString},
+    };
+
+    let filter = std::env::var("PT_FILTER").unwrap_or_default();
+    if !filter.is_empty() && !name.contains(&filter) {
+        return;
+    }
+
+    let mut output = String::new();
+    {
+        struct DumpOut<'a>(&'a mut String);
+        impl Drop for DumpOut<'_> {
+            fn drop(&mut self) {
+                if std::thread::panicking() {
+                    std::println!("{}", self.0);
+                }
+            }
+        }
+
+        let dump = DumpOut(&mut output);
+        test(ident, input, dump.0);
+    }
+
+    let mut root = PathBuf::from(
+        std::env::var("PT_TEST_ROOT")
+            .unwrap_or(concat!(env!("CARGO_MANIFEST_DIR"), "/tests").to_string()),
+    );
+    root.push(name.replace("::", "_").replace(concat!(env!("CARGO_PKG_NAME"), "_"), ""));
+    root.set_extension("txt");
+
+    let expected = std::fs::read_to_string(&root).unwrap_or_default();
+
+    if output == expected {
+        return;
+    }
+
+    if std::env::var("PT_UPDATE").is_ok() {
+        std::fs::write(&root, output).unwrap();
+        return;
+    }
+
+    if !root.exists() {
+        std::fs::create_dir_all(root.parent().unwrap()).unwrap();
+        std::fs::write(&root, vec![]).unwrap();
+    }
+
+    let mut proc = std::process::Command::new("diff")
+        .arg("-u")
+        .arg("--color")
+        .arg(&root)
+        .arg("-")
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::inherit())
+        .spawn()
+        .unwrap();
+
+    proc.stdin.as_mut().unwrap().write_all(output.as_bytes()).unwrap();
+
+    proc.wait().unwrap();
+
+    panic!("test failed");
+}
+
+#[cfg(test)]
+fn test_parse_files(
+    ident: &str,
+    input: &str,
+    ctx: &mut parser::Ctx,
+) -> (Vec<parser::Ast>, Vec<Vec<u8>>) {
+    use {
+        self::parser::FileKind,
+        std::{borrow::ToOwned, string::ToString},
+    };
+
+    let mut module_map = Vec::new();
+    let mut embed_map = Vec::new();
+    let mut last_start = 0;
+    let mut last_module_name = "test.hb";
+    for (i, m) in input.match_indices("// in module: ") {
+        if last_module_name.ends_with(".hb") {
+            fmt::test::format(ident, input[last_start..i].trim());
+            module_map.push((last_module_name, &input[last_start..i]));
+        } else {
+            embed_map.push((last_module_name, &input[last_start..i]));
+        }
+        let (module_name, _) = input[i + m.len()..].split_once('\n').unwrap();
+        last_module_name = module_name;
+        last_start = i + m.len() + module_name.len() + 1;
+    }
+    if last_module_name.ends_with(".hb") {
+        fmt::test::format(ident, input[last_start..].trim());
+        module_map.push((last_module_name, &input[last_start..]));
+    } else {
+        embed_map.push((last_module_name, &input[last_start..]));
+    }
+
+    let mut loader = |path: &str, _: &str, kind| match kind {
+        FileKind::Module => module_map
+            .iter()
+            .position(|&(name, _)| name == path)
+            .ok_or("Module Not Found".to_string()),
+        FileKind::Embed => embed_map
+            .iter()
+            .position(|&(name, _)| name == path)
+            .ok_or("Embed Not Found".to_string()),
+    };
+
+    (
+        module_map
+            .iter()
+            .map(|&(path, content)| parser::Ast::new(path, content.to_owned(), ctx, &mut loader))
+            .collect(),
+        embed_map.iter().map(|&(_, content)| content.to_owned().into_bytes()).collect(),
+    )
+}
+
+#[cfg(feature = "std")]
+static CWD: std::sync::LazyLock<std::path::PathBuf> =
+    std::sync::LazyLock::new(|| std::env::current_dir().unwrap_or_default());
+
+#[cfg(feature = "std")]
+pub fn strip_cwd(path: &str) -> &str {
+    std::path::Path::new(path)
+        .strip_prefix(&*CWD)
+        .unwrap_or(std::path::Path::new(path))
+        .to_str()
+        .unwrap()
+}
+
+#[cfg(feature = "std")]
+pub fn display_rel_path(path: &(impl AsRef<std::ffi::OsStr> + ?Sized)) -> std::path::Display {
+    std::path::Path::new(path).strip_prefix(&*CWD).unwrap_or(std::path::Path::new(path)).display()
+}
+
+#[cfg(not(feature = "std"))]
+pub fn display_rel_path(path: &str) -> &str {
+    path
+}