some start for homemade regalloc

Reviewed-on: https://git.ablecorp.us/AbleOS/holey-bytes/pulls/20

.cargo/config.toml

@@ -0,0 +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 +1,12 @@
+# garbage
 /target
+rustc-ice-*
+
+# sqlite
+db.sqlite
+db.sqlite-journal
+
+# assets
+/depell/src/*.gz
+/depell/src/*.wasm
+/bytecode/src/instrs.rs

Cargo.toml

@@ -1,2 +1,50 @@
+cargo-features = ["profile-rustflags"]
+
 [workspace]
-members = ["hbvm", "compiler"]
+resolver = "2"
+members = [
+	"bytecode",
+	"vm",
+	"xrt",
+	"xtask",
+	"lang",
+	"depell",
+	"depell/wasm-fmt",
+	"depell/wasm-hbc",
+	"depell/wasm-rt",
+]
+
+[workspace.dependencies]
+hbbytecode = { path = "bytecode", default-features = false }
+hbvm = { path = "vm", default-features = false }
+hbxrt = { path = "xrt" }
+hblang = { path = "lang", default-features = false }
+hbjit = { path = "jit" }
+
+[profile.release]
+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 = "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"

DESIGN_DOC.md

@@ -1,28 +0,0 @@
-# Math operations
-```
-MATH_OP
-    Add
-    Sub
-    Mul
-    Div
-    Mod
-```
-```
-MATH_TYPE
-    Unsigned
-    Signed
-    FloatingPoint
-```
-
-```
-MATH_OP_SIDES
-    Register Constant
-    Register Register
-    Constant Constant
-    Constant Register
-```
-`[MATH_OP] [MATH_OP_SIDES] [MATH_TYPE] [IMM_LHS] [IMM_RHS] [REG]`
-
-
-
-

assets/example.asm

@@ -1,4 +0,0 @@
-load 0 a0        ;; 05 00 A0
-load 10 a1       ;; 05 10 A1
-add a0 1 a0      ;; 01 A0 01 A0
-jump_neq a0 a1 0 ;; a1 A0 A1 0

assets/example.bytes

@@ -1,4 +0,0 @@
-load 10 A1
-load 0 A0
-add A0 1
-jump_less_than A0 A1 0

bytecode/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "hbbytecode"
+version = "0.1.0"
+edition = "2018"
+
+[features]
+default = ["disasm"]
+std = []
+disasm = ["std"]
+

bytecode/build.rs

@@ -0,0 +1,204 @@
+#![feature(iter_next_chunk)]
+
+use std::{collections::HashSet, fmt::Write};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=instructions.in");
+
+    let mut generated = String::new();
+    gen_instrs(&mut generated)?;
+    std::fs::write("src/instrs.rs", generated)?;
+
+    Ok(())
+}
+
+fn gen_instrs(generated: &mut String) -> Result<(), Box<dyn std::error::Error>> {
+    writeln!(generated, "#![expect(dead_code)]")?;
+    writeln!(generated, "use crate::*;")?;
+
+    '_opcode_structs: {
+        let mut seen = HashSet::new();
+        for [.., args, _] in instructions() {
+            if !seen.insert(args) {
+                continue;
+            }
+
+            writeln!(generated, "#[derive(Clone, Copy, Debug)]")?;
+            writeln!(generated, "#[repr(packed)]")?;
+            write!(generated, "pub struct Ops{args}(")?;
+            let mut first = true;
+            for ch in args.chars().filter(|&ch| ch != 'N') {
+                if !std::mem::take(&mut first) {
+                    write!(generated, ",")?;
+                }
+                write!(generated, "pub Op{ch}")?;
+            }
+            writeln!(generated, ");")?;
+            writeln!(generated, "unsafe impl BytecodeItem for Ops{args} {{}}")?;
+        }
+    }
+
+    '_max_size: {
+        let max = instructions()
+            .map(
+                |[_, _, ty, _]| {
+                    if ty == "N" {
+                        1
+                    } else {
+                        iter_args(ty).map(arg_to_width).sum::<usize>() + 1
+                    }
+                },
+            )
+            .max()
+            .unwrap();
+
+        writeln!(generated, "pub const MAX_SIZE: usize = {max};")?;
+    }
+
+    '_encoders: {
+        for [op, name, ty, doc] in instructions() {
+            writeln!(generated, "/// {}", doc.trim_matches('"'))?;
+            let name = name.to_lowercase();
+            let args = comma_sep(
+                iter_args(ty)
+                    .enumerate()
+                    .map(|(i, c)| format!("{}{i}: {}", arg_to_name(c), arg_to_type(c))),
+            );
+            writeln!(generated, "pub fn {name}({args}) -> (usize, [u8; MAX_SIZE]) {{")?;
+            let arg_names =
+                comma_sep(iter_args(ty).enumerate().map(|(i, c)| format!("{}{i}", arg_to_name(c))));
+            writeln!(generated, "    unsafe {{ crate::encode({ty}({op}, {arg_names})) }}")?;
+            writeln!(generated, "}}")?;
+        }
+    }
+
+    '_structs: {
+        let mut seen = std::collections::HashSet::new();
+        for [_, _, ty, _] in instructions() {
+            if !seen.insert(ty) {
+                continue;
+            }
+            let types = comma_sep(iter_args(ty).map(arg_to_type).map(|s| s.to_string()));
+            writeln!(generated, "#[repr(packed)] pub struct {ty}(u8, {types});")?;
+        }
+    }
+
+    '_name_list: {
+        writeln!(generated, "pub const COUNT: u8 = {};", instructions().count())?;
+    }
+
+    let instr = "Instr";
+    let oper = "Oper";
+
+    '_instr_enum: {
+        writeln!(generated, "#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(u8)]")?;
+        writeln!(generated, "pub enum {instr} {{")?;
+        for [id, name, ..] in instructions() {
+            writeln!(generated, "    {name} = {id},")?;
+        }
+        writeln!(generated, "}}")?;
+    }
+
+    '_arg_kind: {
+        writeln!(generated, "#[derive(Debug, Clone, Copy, PartialEq, Eq)]")?;
+        writeln!(generated, "pub enum {oper} {{")?;
+        let mut seen = HashSet::new();
+        for ty in instructions().flat_map(|[.., ty, _]| iter_args(ty)) {
+            if !seen.insert(ty) {
+                continue;
+            }
+            writeln!(generated, "    {ty}({}),", arg_to_type(ty))?;
+        }
+        writeln!(generated, "}}")?;
+    }
+
+    '_parse_opers: {
+        writeln!(
+            generated,
+            "/// 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 alloc::vec::Vec<{oper}>) -> Option<()> {{")?;
+        writeln!(generated, "    match kind {{")?;
+        let mut instrs = instructions().collect::<Vec<_>>();
+        instrs.sort_unstable_by_key(|&[.., ty, _]| ty);
+        for group in instrs.chunk_by(|[.., a, _], [.., b, _]| a == b) {
+            let ty = group[0][2];
+            for &[_, name, ..] in group {
+                writeln!(generated, "        | {instr}::{name}")?;
+            }
+            generated.pop();
+            writeln!(generated, " => {{")?;
+            if iter_args(ty).count() != 0 {
+                writeln!(generated, "            let data = crate::decode::<{ty}>(bytes)?;")?;
+                writeln!(
+                    generated,
+                    "            buf.extend([{}]);",
+                    comma_sep(
+                        iter_args(ty).zip(1u32..).map(|(t, i)| format!("{oper}::{t}(data.{i})"))
+                    )
+                )?;
+            } else {
+                writeln!(generated, "            crate::decode::<{ty}>(bytes)?;")?;
+            }
+
+            writeln!(generated, "        }}")?;
+        }
+        writeln!(generated, "    }}")?;
+        writeln!(generated, "    Some(())")?;
+        writeln!(generated, "}}")?;
+    }
+
+    std::fs::write("src/instrs.rs", generated)?;
+    Ok(())
+}
+
+fn comma_sep(items: impl Iterator<Item = String>) -> String {
+    items.map(|item| item.to_string()).collect::<Vec<_>>().join(", ")
+}
+
+fn instructions() -> impl Iterator<Item = [&'static str; 4]> {
+    include_str!("instructions.in")
+        .lines()
+        .filter_map(|line| line.strip_suffix(';'))
+        .map(|line| line.splitn(4, ',').map(str::trim).next_chunk().unwrap())
+}
+
+fn arg_to_type(arg: char) -> &'static str {
+    match arg {
+        'R' | 'B' => "u8",
+        'H' => "u16",
+        'W' => "u32",
+        'D' | 'A' => "u64",
+        'P' => "i16",
+        'O' => "i32",
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn arg_to_width(arg: char) -> usize {
+    match arg {
+        'R' | 'B' => 1,
+        'H' => 2,
+        'W' => 4,
+        'D' | 'A' => 8,
+        'P' => 2,
+        'O' => 4,
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn arg_to_name(arg: char) -> &'static str {
+    match arg {
+        'R' => "reg",
+        'B' | 'H' | 'W' | 'D' => "imm",
+        'P' | 'O' => "offset",
+        'A' => "addr",
+        _ => panic!("unknown type: {}", arg),
+    }
+}
+
+fn iter_args(ty: &'static str) -> impl Iterator<Item = char> {
+    ty.chars().filter(|c| *c != 'N')
+}

bytecode/hbbytecode.h

@@ -0,0 +1,75 @@
+/* HoleyBytes Bytecode representation in C
+ * Requires C23 compiler or better
+ *
+ * Uses MSVC pack pragma extension,
+ * proved to work with Clang and GNU® GCC™.
+ */
+
+#pragma once
+#include <assert.h>
+#include <limits.h>
+#include <stdint.h>
+
+static_assert(CHAR_BIT == 8, "Cursed architectures are not supported");
+
+enum hbbc_Opcode: uint8_t {
+    hbbc_Op_UN    , hbbc_Op_TX   , hbbc_Op_NOP   , hbbc_Op_ADD   , hbbc_Op_SUB   , hbbc_Op_MUL   ,
+    hbbc_Op_AND   , hbbc_Op_OR   , hbbc_Op_XOR   , hbbc_Op_SL    , hbbc_Op_SR    , hbbc_Op_SRS   ,
+    hbbc_Op_CMP   , hbbc_Op_CMPU , hbbc_Op_DIR   , hbbc_Op_NEG   , hbbc_Op_NOT   , hbbc_Op_ADDI  , 
+    hbbc_Op_MULI  , hbbc_Op_ANDI , hbbc_Op_ORI   , hbbc_Op_XORI  , hbbc_Op_SLI   , hbbc_Op_SRI   ,
+    hbbc_Op_SRSI  , hbbc_Op_CMPI , hbbc_Op_CMPUI , hbbc_Op_CP    , hbbc_Op_SWA   , hbbc_Op_LI    ,
+    hhbc_Op_LRA   , hbbc_Op_LD   , hbbc_Op_ST    , hbbc_Op_LDR   , hhbc_Op_STR   , hbbc_Op_BMC   ,
+    hbbc_Op_BRC   , hbbc_Op_JMP  , hbbc_Op_JMPR  , hbbc_Op_JAL   , hbbc_Op_JALR  , hbbc_Op_JEQ   ,
+    hbbc_Op_JNE   , hbbc_Op_JLT  , hbbc_Op_JGT   , hbbc_Op_JLTU  , hbbc_Op_JGTU  , hbbc_Op_ECALL ,
+    hbbc_Op_ADDF  , hbbc_Op_SUBF , hbbc_Op_MULF  , hbbc_Op_DIRF  , hbbc_Op_FMAF  , hbbc_Op_NEGF  ,
+    hbbc_Op_ITF   , hbbc_Op_FTI  , hbbc_Op_ADDFI , hbbc_Op_MULFI ,
+} typedef hbbc_Opcode;
+
+static_assert(sizeof(hbbc_Opcode) == 1);
+
+#pragma pack(push, 1)
+struct hbbc_ParamBBBB
+    { uint8_t _0; uint8_t _1; uint8_t _2; uint8_t _3; }
+    typedef hbbc_ParamBBBB;
+    static_assert(sizeof(hbbc_ParamBBBB) == 32 / 8);
+
+struct hbbc_ParamBBB
+    { uint8_t _0; uint8_t _1; uint8_t _2; }
+    typedef hbbc_ParamBBB;
+    static_assert(sizeof(hbbc_ParamBBB) == 24 / 8);
+
+struct hbbc_ParamBBDH
+    { uint8_t _0; uint8_t _1; uint64_t _2; uint16_t _3; }
+    typedef hbbc_ParamBBDH;
+    static_assert(sizeof(hbbc_ParamBBDH) == 96 / 8);
+
+struct hbbc_ParamBBWH
+    { uint8_t _0; uint8_t _1; uint32_t _2; uint16_t _3; }
+    typedef hbbc_ParamBBWH;
+    static_assert(sizeof(hbbc_ParamBBWH) == 64 / 8);
+
+
+struct hbbc_ParamBBD
+    { uint8_t _0; uint8_t _1; uint64_t _2; }
+    typedef hbbc_ParamBBD;
+    static_assert(sizeof(hbbc_ParamBBD) == 80 / 8);
+
+struct hbbc_ParamBBW
+    { uint8_t _0; uint8_t _1; uint32_t _2; }
+    typedef hbbc_ParamBBW;
+    static_assert(sizeof(hbbc_ParamBBW) == 48 / 8);
+
+struct hbbc_ParamBB
+    { uint8_t _0; uint8_t _1; }
+    typedef hbbc_ParamBB;
+    static_assert(sizeof(hbbc_ParamBB) == 16 / 8);
+
+struct hbbc_ParamBD
+    { uint8_t _0; uint64_t _1; }
+    typedef hbbc_ParamBD;
+    static_assert(sizeof(hbbc_ParamBD) == 72 / 8);
+
+typedef uint64_t hbbc_ParamD;
+    static_assert(sizeof(hbbc_ParamD) == 64 / 8);
+
+#pragma pack(pop)

bytecode/instructions.in

@@ -0,0 +1,120 @@
+0x00, UN,       N,    "Cause an unreachable code trap"              ;
+0x01, TX,       N,    "Termiante execution"                         ;
+0x02, NOP,      N,    "Do nothing"                                  ;
+0x03, ADD8,     RRR,  "Addition (8b)"                               ;
+0x04, ADD16,    RRR,  "Addition (16b)"                              ;
+0x05, ADD32,    RRR,  "Addition (32b)"                              ;
+0x06, ADD64,    RRR,  "Addition (64b)"                              ;
+0x07, SUB8,     RRR,  "Subtraction (8b)"                            ;
+0x08, SUB16,    RRR,  "Subtraction (16b)"                           ;
+0x09, SUB32,    RRR,  "Subtraction (32b)"                           ;
+0x0A, SUB64,    RRR,  "Subtraction (64b)"                           ;
+0x0B, MUL8,     RRR,  "Multiplication (8b)"                         ;
+0x0C, MUL16,    RRR,  "Multiplication (16b)"                        ;
+0x0D, MUL32,    RRR,  "Multiplication (32b)"                        ;
+0x0E, MUL64,    RRR,  "Multiplication (64b)"                        ;
+0x0F, AND,      RRR,  "Bitand"                                      ;
+0x10, OR,       RRR,  "Bitor"                                       ;
+0x11, XOR,      RRR,  "Bitxor"                                      ;
+0x12, SLU8,     RRR,  "Unsigned left bitshift (8b)"                 ;
+0x13, SLU16,    RRR,  "Unsigned left bitshift (16b)"                ;
+0x14, SLU32,    RRR,  "Unsigned left bitshift (32b)"                ;
+0x15, SLU64,    RRR,  "Unsigned left bitshift (64b)"                ;
+0x16, SRU8,     RRR,  "Unsigned right bitshift (8b)"                ;
+0x17, SRU16,    RRR,  "Unsigned right bitshift (16b)"               ;
+0x18, SRU32,    RRR,  "Unsigned right bitshift (32b)"               ;
+0x19, SRU64,    RRR,  "Unsigned right bitshift (64b)"               ;
+0x1A, SRS8,     RRR,  "Signed right bitshift (8b)"                  ;
+0x1B, SRS16,    RRR,  "Signed right bitshift (16b)"                 ;
+0x1C, SRS32,    RRR,  "Signed right bitshift (32b)"                 ;
+0x1D, SRS64,    RRR,  "Signed right bitshift (64b)"                 ;
+0x1E, CMPU,     RRR,  "Unsigned comparsion"                         ;
+0x1F, CMPS,     RRR,  "Signed comparsion"                           ;
+0x20, DIRU8,    RRRR, "Merged divide-remainder (unsigned 8b)"       ;
+0x21, DIRU16,   RRRR, "Merged divide-remainder (unsigned 16b)"      ;
+0x22, DIRU32,   RRRR, "Merged divide-remainder (unsigned 32b)"      ;
+0x23, DIRU64,   RRRR, "Merged divide-remainder (unsigned 64b)"      ;
+0x24, DIRS8,    RRRR, "Merged divide-remainder (signed 8b)"         ;
+0x25, DIRS16,   RRRR, "Merged divide-remainder (signed 16b)"        ;
+0x26, DIRS32,   RRRR, "Merged divide-remainder (signed 32b)"        ;
+0x27, DIRS64,   RRRR, "Merged divide-remainder (signed 64b)"        ;
+0x28, NEG,      RR,   "Bit negation"                                ;
+0x29, NOT,      RR,   "Logical negation"                            ;
+0x2A, SXT8,     RR,   "Sign extend 8b to 64b"                       ;
+0x2B, SXT16,    RR,   "Sign extend 16b to 64b"                      ;
+0x2C, SXT32,    RR,   "Sign extend 32b to 64b"                      ;
+0x2D, ADDI8,    RRB,  "Addition with immediate (8b)"                ;
+0x2E, ADDI16,   RRH,  "Addition with immediate (16b)"               ;
+0x2F, ADDI32,   RRW,  "Addition with immediate (32b)"               ;
+0x30, ADDI64,   RRD,  "Addition with immediate (64b)"               ;
+0x31, MULI8,    RRB,  "Multiplication with immediate (8b)"          ;
+0x32, MULI16,   RRH,  "Multiplication with immediate (16b)"         ;
+0x33, MULI32,   RRW,  "Multiplication with immediate (32b)"         ;
+0x34, MULI64,   RRD,  "Multiplication with immediate (64b)"         ;
+0x35, ANDI,     RRD,  "Bitand with immediate"                       ;
+0x36, ORI,      RRD,  "Bitor with immediate"                        ;
+0x37, XORI,     RRD,  "Bitxor with immediate"                       ;
+0x38, SLUI8,    RRB,  "Unsigned left bitshift with immedidate (8b)" ;
+0x39, SLUI16,   RRB,  "Unsigned left bitshift with immedidate (16b)";
+0x3A, SLUI32,   RRB,  "Unsigned left bitshift with immedidate (32b)";
+0x3B, SLUI64,   RRB,  "Unsigned left bitshift with immedidate (64b)";
+0x3C, SRUI8,    RRB,  "Unsigned right bitshift with immediate (8b)" ;
+0x3D, SRUI16,   RRB,  "Unsigned right bitshift with immediate (16b)";
+0x3E, SRUI32,   RRB,  "Unsigned right bitshift with immediate (32b)";
+0x3F, SRUI64,   RRB,  "Unsigned right bitshift with immediate (64b)";
+0x40, SRSI8,    RRB,  "Signed right bitshift with immediate"        ;
+0x41, SRSI16,   RRB,  "Signed right bitshift with immediate"        ;
+0x42, SRSI32,   RRB,  "Signed right bitshift with immediate"        ;
+0x43, SRSI64,   RRB,  "Signed right bitshift with immediate"        ;
+0x44, CMPUI,    RRD,  "Unsigned compare with immediate"             ;
+0x45, CMPSI,    RRD,  "Signed compare with immediate"               ;
+0x46, CP,       RR,   "Copy register"                               ;
+0x47, SWA,      RR,   "Swap registers"                              ;
+0x48, LI8,      RB,   "Load immediate (8b)"                         ;
+0x49, LI16,     RH,   "Load immediate (16b)"                        ;
+0x4A, LI32,     RW,   "Load immediate (32b)"                        ;
+0x4B, LI64,     RD,   "Load immediate (64b)"                        ;
+0x4C, LRA,      RRO,  "Load relative address"                       ;
+0x4D, LD,       RRAH, "Load from absolute address"                  ;
+0x4E, ST,       RRAH, "Store to absolute address"                   ;
+0x4F, LDR,      RROH, "Load from relative address"                  ;
+0x50, STR,      RROH, "Store to relative address"                   ;
+0x51, BMC,      RRH,  "Copy block of memory"                        ;
+0x52, BRC,      RRB,  "Copy register block"                         ;
+0x53, JMP,      O,    "Relative jump"                               ;
+0x54, JAL,      RRO,  "Linking relative jump"                       ;
+0x55, JALA,     RRA,  "Linking absolute jump"                       ;
+0x56, JEQ,      RRP,  "Branch on equal"                             ;
+0x57, JNE,      RRP,  "Branch on nonequal"                          ;
+0x58, JLTU,     RRP,  "Branch on lesser-than (unsigned)"            ;
+0x59, JGTU,     RRP,  "Branch on greater-than (unsigned)"           ;
+0x5A, JLTS,     RRP,  "Branch on lesser-than (signed)"              ;
+0x5B, JGTS,     RRP,  "Branch on greater-than (signed)"             ;
+0x5C, ECA,      N,    "Environment call trap"                       ;
+0x5D, EBP,      N,    "Environment breakpoint"                      ;
+0x5E, FADD32,   RRR,  "Floating point addition (32b)"               ;
+0x5F, FADD64,   RRR,  "Floating point addition (64b)"               ;
+0x60, FSUB32,   RRR,  "Floating point subtraction (32b)"            ;
+0x61, FSUB64,   RRR,  "Floating point subtraction (64b)"            ;
+0x62, FMUL32,   RRR,  "Floating point multiply (32b)"               ;
+0x63, FMUL64,   RRR,  "Floating point multiply (64b)"               ;
+0x64, FDIV32,   RRR,  "Floating point division (32b)"               ;
+0x65, FDIV64,   RRR,  "Floating point division (64b)"               ;
+0x66, FMA32,    RRRR, "Float fused multiply-add (32b)"              ;
+0x67, FMA64,    RRRR, "Float fused multiply-add (64b)"              ;
+0x68, FINV32,   RR,   "Float reciprocal (32b)"                      ;
+0x69, FINV64,   RR,   "Float reciprocal (64b)"                      ;
+0x6A, FCMPLT32, RRR,  "Flaot compare less than (32b)"               ;
+0x6B, FCMPLT64, RRR,  "Flaot compare less than (64b)"               ;
+0x6C, FCMPGT32, RRR,  "Flaot compare greater than (32b)"            ;
+0x6D, FCMPGT64, RRR,  "Flaot compare greater than (64b)"            ;
+0x6E, ITF32,    RR,   "Int to 32 bit float"                         ;
+0x6F, ITF64,    RR,   "Int to 64 bit float"                         ;
+0x70, FTI32,    RRB,  "Float 32 to int"                             ;
+0x71, FTI64,    RRB,  "Float 64 to int"                             ;
+0x72, FC32T64,  RR,   "Float 64 to Float 32"                        ;
+0x73, FC64T32,  RRB,  "Float 32 to Float 64"                        ;
+0x74, LRA16,    RRP,  "Load relative immediate (16 bit)"            ;
+0x75, LDR16,    RRPH, "Load from relative address (16 bit)"         ;
+0x76, STR16,    RRPH, "Store to relative address (16 bit)"          ;
+0x77, JMP16,    P,    "Relative jump (16 bit)"                      ;

bytecode/src/lib.rs

@@ -0,0 +1,284 @@
+#![no_std]
+
+#[cfg(feature = "disasm")]
+extern crate alloc;
+
+pub use crate::instrs::*;
+use core::convert::TryFrom;
+
+mod instrs;
+
+type OpR = u8;
+
+type OpA = u64;
+type OpO = i32;
+type OpP = i16;
+
+type OpB = u8;
+type OpH = u16;
+type OpW = u32;
+type OpD = u64;
+
+/// # Safety
+/// Has to be valid to be decoded from bytecode.
+pub unsafe trait BytecodeItem {}
+unsafe impl BytecodeItem for u8 {}
+
+impl TryFrom<u8> for Instr {
+    type Error = u8;
+
+    #[inline]
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        #[cold]
+        fn failed(value: u8) -> Result<Instr, u8> {
+            Err(value)
+        }
+
+        if value < COUNT {
+            unsafe { Ok(core::mem::transmute::<u8, Instr>(value)) }
+        } else {
+            failed(value)
+        }
+    }
+}
+
+#[inline]
+unsafe fn encode<T>(instr: T) -> (usize, [u8; instrs::MAX_SIZE]) {
+    let mut buf = [0; instrs::MAX_SIZE];
+    core::ptr::write(buf.as_mut_ptr() as *mut T, instr);
+    (core::mem::size_of::<T>(), buf)
+}
+
+#[inline]
+#[cfg(feature = "disasm")]
+fn decode<T>(binary: &mut &[u8]) -> Option<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)) }
+}
+
+/// Rounding mode
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum RoundingMode {
+    NearestEven = 0,
+    Truncate = 1,
+    Up = 2,
+    Down = 3,
+}
+
+impl TryFrom<u8> for RoundingMode {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        (value <= 3).then(|| unsafe { core::mem::transmute(value) }).ok_or(())
+    }
+}
+
+#[cfg(feature = "disasm")]
+#[derive(Clone, Copy)]
+pub enum DisasmItem {
+    Func,
+    Global,
+}
+
+#[cfg(feature = "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: &alloc::collections::BTreeMap<u32, (&'a str, u32, DisasmItem)>,
+    out: &mut alloc::string::String,
+    mut eca_handler: impl FnMut(&mut &[u8]),
+) -> Result<(), DisasmError<'a>> {
+    use {
+        self::instrs::Instr,
+        alloc::{
+            collections::btree_map::{BTreeMap, Entry},
+            vec::Vec,
+        },
+        core::{convert::TryInto, fmt::Write},
+    };
+
+    fn instr_from_byte(b: u8) -> Result<Instr, DisasmError<'static>> {
+        b.try_into().map_err(DisasmError::InvalidInstruction)
+    }
+
+    let mut labels = BTreeMap::<u32, u32>::default();
+    let mut buf = Vec::<instrs::Oper>::new();
+    let mut has_oob = false;
+
+    '_offset_pass: for (&off, &(name, len, kind)) in functions.iter() {
+        if matches!(kind, DisasmItem::Global) {
+            continue;
+        }
+
+        let prev = *binary;
+
+        *binary = &binary[off as usize..];
+
+        let mut label_count = 0;
+        while let Some(&byte) = binary.first() {
+            let offset: i32 = (prev.len() - binary.len()).try_into().unwrap();
+            if offset as u32 == off + len {
+                break;
+            }
+            let Ok(inst) = instr_from_byte(byte) else { break };
+            instrs::parse_args(binary, inst, &mut buf)
+                .ok_or(DisasmError::InstructionOutOfBounds(name))?;
+
+            for op in buf.drain(..) {
+                let rel = match op {
+                    instrs::Oper::O(rel) => rel,
+                    instrs::Oper::P(rel) => rel.into(),
+                    _ => continue,
+                };
+
+                let global_offset: u32 = (offset + rel).try_into().unwrap();
+                if functions.get(&global_offset).is_some() {
+                    continue;
+                }
+                label_count += match labels.entry(global_offset) {
+                    Entry::Occupied(_) => 0,
+                    Entry::Vacant(entry) => {
+                        entry.insert(label_count);
+                        1
+                    }
+                }
+            }
+
+            if matches!(inst, Instr::ECA) {
+                eca_handler(binary);
+            }
+        }
+
+        *binary = prev;
+    }
+
+    let mut ordered = functions.iter().collect::<Vec<_>>();
+    ordered.sort_unstable_by_key(|(_, (name, _, _))| name);
+
+    '_dump: for (&off, &(name, len, kind)) in ordered {
+        if matches!(kind, DisasmItem::Global) {
+            continue;
+        }
+        let prev = *binary;
+
+        writeln!(out, "{name}:")?;
+
+        *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 {
+                break;
+            }
+            let Ok(inst) = instr_from_byte(byte) else {
+                writeln!(out, "invalid instr {byte}")?;
+                break;
+            };
+            instrs::parse_args(binary, inst, &mut buf).unwrap();
+
+            if let Some(label) = labels.get(&offset.try_into().unwrap()) {
+                write!(out, "{:>2}: ", label)?;
+            } else {
+                write!(out, "    ")?;
+            }
+
+            write!(out, "{inst:<8?} ")?;
+
+            'a: for (i, op) in buf.drain(..).enumerate() {
+                if i != 0 {
+                    write!(out, ", ")?;
+                }
+
+                let rel = 'b: {
+                    match op {
+                        instrs::Oper::O(rel) => break 'b rel,
+                        instrs::Oper::P(rel) => break 'b rel.into(),
+                        instrs::Oper::R(r) => write!(out, "r{r}")?,
+                        instrs::Oper::B(b) => write!(out, "{b}b")?,
+                        instrs::Oper::H(h) => write!(out, "{h}h")?,
+                        instrs::Oper::W(w) => write!(out, "{w}w")?,
+                        instrs::Oper::D(d) if (d as i64) < 0 => write!(out, "{}d", d as i64)?,
+                        instrs::Oper::D(d) => write!(out, "{d}d")?,
+                        instrs::Oper::A(a) => write!(out, "{a}a")?,
+                    }
+
+                    continue 'a;
+                };
+
+                let global_offset: u32 = (offset + rel).try_into().unwrap();
+                if let Some(&(name, ..)) = functions.get(&global_offset) {
+                    if name.contains('\0') {
+                        write!(out, ":{name:?}")?;
+                    } else {
+                        write!(out, ":{name}")?;
+                    }
+                } else {
+                    let local_has_oob = global_offset < off
+                        || global_offset > off + len
+                        || prev
+                            .get(global_offset as usize)
+                            .map_or(true, |&b| instr_from_byte(b).is_err())
+                        || prev[global_offset as usize] == 0;
+                    has_oob |= local_has_oob;
+                    let label = labels.get(&global_offset).unwrap();
+                    if local_has_oob {
+                        write!(out, "!!!!!!!!!{rel}")?;
+                    } else {
+                        write!(out, ":{label}")?;
+                    }
+                }
+            }
+
+            writeln!(out)?;
+
+            if matches!(inst, Instr::ECA) {
+                eca_handler(binary);
+            }
+        }
+
+        *binary = prev;
+    }
+
+    if has_oob {
+        return Err(DisasmError::HasOutOfBoundsJumps);
+    }
+
+    Ok(())
+}

compiler/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "compiler"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]

compiler/src/main.rs

@@ -1,5 +0,0 @@
-fn main() {
-    let prog = "load 1, A0
-    jump 0";
-    println!("Hello, world!");
-}

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/index.css

@@ -0,0 +1,143 @@
+* {
+	font-family: var(--font);
+}
+
+body {
+	--primary: white;
+	--secondary: #EFEFEF;
+	--timestamp: #777777;
+	--error: #ff3333;
+	--placeholder: #333333;
+}
+
+
+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 {
+	div.info {
+		display: flex;
+		gap: var(--small-gap);
+
+		span[apply=timestamp] {
+			color: var(--timestamp);
+		}
+	}
+
+	div.stats {
+		display: flex;
+		gap: var(--small-gap);
+	}
+}
+
+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;
+}
+
+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);
+}
+
+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;
+		}
+	}
+}

depell/src/index.js

@@ -0,0 +1,427 @@
+/// @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) {
+	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);
+}
+
+/**@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 {"fmt" | "minify"} action
+ * @returns {string | undefined} */
+function modifyCode(instance, code, action) {
+	let {
+		INPUT, INPUT_LEN,
+		OUTPUT, OUTPUT_LEN,
+		memory, fmt, minify
+	} = instance.exports;
+
+	if (!(true
+		&& memory instanceof WebAssembly.Memory
+		&& INPUT instanceof WebAssembly.Global
+		&& INPUT_LEN instanceof WebAssembly.Global
+		&& OUTPUT instanceof WebAssembly.Global
+		&& OUTPUT_LEN instanceof WebAssembly.Global
+		&& typeof fmt === "function"
+		&& typeof minify === "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));
+
+	return runWasmFunction(instance, action === "fmt" ? fmt : minify) ?
+		bufToString(memory, OUTPUT, OUTPUT_LEN) : undefined;
+}
+
+
+/** @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 {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 {string} code
+ * @param {string[]} roots
+ * @param {Post[]} buf
+ * @param {Set<string>} prevRoots
+ * @returns {void} */
+function loadCachedPackages(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);
+		buf.push({ path: imp, code: localStorage.getItem("package-" + imp) ?? never() });
+		for (const match of buf[buf.length - 1].code.matchAll(importRe)) {
+			roots.push(match[1]);
+		}
+	}
+}
+
+/**@type{Set<string>}*/ const prevRoots = new Set();
+
+/** @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();
+	const keyBuf = [];
+	/**@type{Post[]}*/
+	const packages = [{ path: "local.hb", code: "" }];
+	const debounce = 100;
+	/**@type{AbortController|undefined}*/
+	let cancelation = undefined;
+	let timeout = 0;
+
+	prevRoots.clear();
+
+	const onInput = () => {
+		importDiff.clear();
+		for (const match of edit.value.matchAll(importRe)) {
+			if (localStorage["package-" + match[1]]) continue;
+			importDiff.add(match[1]);
+		}
+
+		if (importDiff.size !== 0) {
+			if (cancelation) cancelation.abort();
+			cancelation = new AbortController();
+
+			keyBuf.length = 0;
+			keyBuf.push(...importDiff.keys());
+
+			errors.textContent = "fetching: " + keyBuf.join(", ");
+
+			fetch(`/code`, {
+				method: "POST",
+				signal: cancelation.signal,
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(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 = keyBuf.filter(i => json[i] === undefined);
+						if (missing.length !== 0) {
+							errors.textContent = "deps not found: " + missing.join(", ");
+						} else {
+							cancelation = undefined;
+							edit.dispatchEvent(new InputEvent("input"));
+						}
+					}
+				} catch (er) {
+					errors.textContent = "completely failed to fetch ("
+						+ e.status + "): " + keyBuf.join(", ");
+					console.error(e, er);
+				}
+			});
+		}
+
+		if (cancelation && importDiff.size !== 0) {
+			return;
+		}
+
+		loadCachedPackages(edit.value, keyBuf, packages, prevRoots);
+
+		errors.textContent = compileCode(hbc, packages, 1);
+		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, white, var(--error) ${perc}%)`;
+		}
+		timeout = 0;
+	};
+
+	edit.addEventListener("input", () => {
+		if (timeout) clearTimeout(timeout);
+		timeout = setTimeout(onInput, debounce)
+	});
+	edit.dispatchEvent(new InputEvent("input"));
+}
+
+/** @type {{ [key: string]: (content: string) => Promise<string> | string }} */
+const applyFns = {
+	timestamp: (content) => new Date(parseInt(content) * 1000).toLocaleString(),
+	fmt: (content) => getFmtInstance().then(i => modifyCode(i, content, "fmt") ?? "invalid code"),
+};
+/** @param {HTMLElement} target */
+function execApply(target) {
+	for (const elem of target.querySelectorAll('[apply]')) {
+		if (!(elem instanceof HTMLElement)) continue;
+		const funcname = elem.getAttribute('apply') ?? never();
+		let res = applyFns[funcname](elem.textContent ?? "");
+		if (res instanceof Promise) res.then(c => elem.textContent = c);
+		else elem.textContent = res;
+	}
+}
+
+/** @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 updaetTab(path) {
+	for (const elem of document.querySelectorAll("button[hx-push-url]")) {
+		if (elem instanceof HTMLButtonElement)
+			elem.disabled = elem.getAttribute("hx-push-url") === (path ?? 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();
+			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\n";
+			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")
+		updaetTab(ev['detail'].pathInfo.finalRequestPath);
+	console.log(ev);
+});
+
+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 });
+});
+
+updaetTab();
+wireUp(document.body);
+

depell/src/main.rs

@@ -0,0 +1,813 @@
+#![feature(iter_collect_into)]
+use {
+    argon2::{password_hash::SaltString, PasswordVerifier},
+    axum::{
+        body::Bytes,
+        extract::Path,
+        http::{header::COOKIE, request::Parts},
+        response::{AppendHeaders, Html},
+    },
+    const_format::formatcp,
+    core::fmt,
+    htmlm::{html, write_html},
+    rand_core::OsRng,
+    serde::{Deserialize, Serialize},
+    std::{
+        collections::{HashMap, HashSet},
+        fmt::{Display, Write},
+        net::Ipv4Addr,
+    },
+};
+
+const MAX_NAME_LENGTH: usize = 32;
+const MAX_POSTNAME_LENGTH: usize = 64;
+const MAX_CODE_LENGTH: usize = 1024 * 4;
+const SESSION_DURATION_SECS: u64 = 60 * 60;
+const MAX_FEED_SIZE: usize = 8 * 1024;
+
+type Redirect<const COUNT: usize = 1> = AppendHeaders<[(&'static str, &'static str); COUNT]>;
+
+macro_rules! static_asset {
+    ($mime:literal, $body:literal) => {
+        get(|| async {
+            axum::http::Response::builder()
+                .header("content-type", $mime)
+                .header("content-encoding", "gzip")
+                .body(axum::body::Body::from(Bytes::from_static(include_bytes!(concat!(
+                    $body, ".gz"
+                )))))
+                .unwrap()
+        })
+    };
+}
+
+async fn amain() {
+    use axum::routing::{delete, get, post};
+
+    let debug = cfg!(debug_assertions);
+
+    log::set_logger(&Logger).unwrap();
+    log::set_max_level(if debug { log::LevelFilter::Warn } else { log::LevelFilter::Error });
+
+    db::init();
+
+    let router = axum::Router::new()
+        .route("/", get(Index::page))
+        .route("/index.css", static_asset!("text/css", "index.css"))
+        .route("/index.js", static_asset!("text/javascript", "index.js"))
+        .route("/hbfmt.wasm", static_asset!("application/wasm", "hbfmt.wasm"))
+        .route("/hbc.wasm", static_asset!("application/wasm", "hbc.wasm"))
+        .route("/index-view", get(Index::get))
+        .route("/feed", get(Feed::page))
+        .route("/feed-view", get(Feed::get))
+        .route("/feed-more", post(Feed::more))
+        .route("/profile", get(Profile::page))
+        .route("/profile-view", get(Profile::get))
+        .route("/profile/:name", get(Profile::get_other_page))
+        .route("/profile-view/:name", get(Profile::get_other))
+        .route("/post", get(Post::page))
+        .route("/post-view", get(Post::get))
+        .route("/post", post(Post::post))
+        .route("/code", post(fetch_code))
+        .route("/login", get(Login::page))
+        .route("/login-view", get(Login::get))
+        .route("/login", post(Login::post))
+        .route("/login", delete(Login::delete))
+        .route("/signup", get(Signup::page))
+        .route("/signup-view", get(Signup::get))
+        .route("/signup", post(Signup::post))
+        .route(
+            "/hot-reload",
+            get({
+                let id = std::time::SystemTime::now()
+                    .duration_since(std::time::SystemTime::UNIX_EPOCH)
+                    .unwrap()
+                    .as_millis();
+                move || async move { id.to_string() }
+            }),
+        );
+
+    #[cfg(feature = "tls")]
+    {
+        let addr =
+            (Ipv4Addr::UNSPECIFIED, std::env::var("DEPELL_PORT").unwrap().parse::<u16>().unwrap());
+        let config = axum_server::tls_rustls::RustlsConfig::from_pem_file(
+            std::env::var("DEPELL_CERT_PATH").unwrap(),
+            std::env::var("DEPELL_KEY_PATH").unwrap(),
+        )
+        .await
+        .unwrap();
+
+        axum_server::bind_rustls(addr.into(), config)
+            .serve(router.into_make_service())
+            .await
+            .unwrap();
+    }
+    #[cfg(not(feature = "tls"))]
+    {
+        let addr = (Ipv4Addr::UNSPECIFIED, 8080);
+        let socket = tokio::net::TcpListener::bind(addr).await.unwrap();
+        axum::serve(socket, router).await.unwrap();
+    }
+}
+
+async fn fetch_code(
+    axum::Json(paths): axum::Json<Vec<String>>,
+) -> axum::Json<HashMap<String, String>> {
+    let mut deps = HashMap::<String, String>::new();
+    db::with(|db| {
+        for path in &paths {
+            let Some((author, name)) = path.split_once('/') else { continue };
+            db.fetch_deps
+                .query_map((name, author), |r| {
+                    Ok((
+                        r.get::<_, String>(1)? + "/" + r.get_ref(0)?.as_str()?,
+                        r.get::<_, String>(2)?,
+                    ))
+                })
+                .log("fetch deps query")
+                .into_iter()
+                .flatten()
+                .filter_map(|r| r.log("deps row"))
+                .collect_into(&mut deps);
+        }
+    });
+    axum::Json(deps)
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum Feed {
+    Before { before_timestamp: u64 },
+}
+
+#[derive(Deserialize)]
+struct Before {
+    before_timestamp: u64,
+}
+
+impl Feed {
+    async fn more(session: Session, axum::Form(data): axum::Form<Before>) -> Html<String> {
+        Self::Before { before_timestamp: data.before_timestamp }.render(&session)
+    }
+}
+
+impl Default for Feed {
+    fn default() -> Self {
+        Self::Before { before_timestamp: now() + 3600 }
+    }
+}
+
+impl Page for Feed {
+    fn render_to_buf(self, _: &Session, buf: &mut String) {
+        db::with(|db| {
+            let cursor = match self {
+                Feed::Before { before_timestamp } => db
+                    .get_pots_before
+                    .query_map((before_timestamp,), Post::from_row)
+                    .log("fetch before posts query")
+                    .into_iter()
+                    .flatten()
+                    .filter_map(|r| r.log("fetch before posts row")),
+            };
+
+            let base_len = buf.len();
+            let mut last_timestamp = None;
+            for post in cursor {
+                write!(buf, "{}", post).unwrap();
+                if buf.len() - base_len > MAX_FEED_SIZE {
+                    last_timestamp = Some(post.timestamp);
+                    break;
+                }
+            }
+
+            write_html!((*buf)
+                if let Some(last_timestamp) = last_timestamp {
+                    <div "hx-post"="/feed-more"
+                        "hx-trigger"="intersect once"
+                        "hx-swap"="outerHTML"
+                        "hx-vals"={format_args!("{{\"before_timestamp\":{last_timestamp}}}")}
+                    >"there might be more"</div>
+                } else {
+                    "no more stuff"
+                }
+            );
+        });
+    }
+}
+
+#[derive(Default)]
+struct Index;
+
+impl PublicPage for Index {
+    fn render_to_buf(self, buf: &mut String) {
+        buf.push_str(include_str!("welcome-page.html"));
+    }
+}
+
+#[derive(Deserialize, Default)]
+struct Post {
+    author: String,
+    name: String,
+    #[serde(skip)]
+    timestamp: u64,
+    #[serde(skip)]
+    imports: usize,
+    #[serde(skip)]
+    runs: usize,
+    #[serde(skip)]
+    dependencies: usize,
+    code: String,
+    #[serde(skip)]
+    error: Option<&'static str>,
+}
+
+impl Page for Post {
+    fn render_to_buf(self, session: &Session, buf: &mut String) {
+        let Self { name, code, error, .. } = self;
+        write_html! { (buf)
+            <form id="postForm" "hx-post"="/post" "hx-swap"="outerHTML">
+                if let Some(e) = error { <div class="error">e</div> }
+                <input name="author" type="text" value={session.name} hidden>
+                <input name="name" type="text" placeholder="name" value=name
+                    required maxlength=MAX_POSTNAME_LENGTH>
+                <div id="code-editor">
+                    <textarea id="code-edit" name="code" placeholder="code" rows=1
+                        required>code</textarea>
+                    <span id="code-size">MAX_CODE_LENGTH</span>
+                </div>
+                <input type="submit" value="submit">
+                <pre id="compiler-output"></pre>
+            </form>
+            !{include_str!("post-page.html")}
+        }
+    }
+}
+
+impl Post {
+    pub fn from_row(r: &rusqlite::Row) -> rusqlite::Result<Self> {
+        Ok(Post {
+            author: r.get(0)?,
+            name: r.get(1)?,
+            timestamp: r.get(2)?,
+            code: r.get(3)?,
+            ..Default::default()
+        })
+    }
+
+    async fn post(
+        session: Session,
+        axum::Form(mut data): axum::Form<Self>,
+    ) -> Result<Redirect, Html<String>> {
+        if data.name.len() > MAX_POSTNAME_LENGTH {
+            data.error = Some(formatcp!("name too long, max length is {MAX_POSTNAME_LENGTH}"));
+            return Err(data.render(&session));
+        }
+
+        if data.code.len() > MAX_CODE_LENGTH {
+            data.error = Some(formatcp!("code too long, max length is {MAX_CODE_LENGTH}"));
+            return Err(data.render(&session));
+        }
+
+        db::with(|db| {
+            if let Err(e) = db.create_post.insert((&data.name, &session.name, now(), &data.code)) {
+                if let rusqlite::Error::SqliteFailure(e, _) = e {
+                    if e.code == rusqlite::ErrorCode::ConstraintViolation {
+                        data.error = Some("this name is already used");
+                    }
+                }
+                data.error = data.error.or_else(|| {
+                    log::error!("create post error: {e}");
+                    Some("internal server error")
+                });
+                return;
+            }
+
+            for (author, name) in hblang::lexer::Lexer::uses(&data.code)
+                .filter_map(|v| v.split_once('/'))
+                .collect::<HashSet<_>>()
+            {
+                if db
+                    .create_import
+                    .insert((author, name, &session.name, &data.name))
+                    .log("create import query")
+                    .is_none()
+                {
+                    data.error = Some("internal server error");
+                    return;
+                };
+            }
+        });
+
+        if data.error.is_some() {
+            Err(data.render(&session))
+        } else {
+            Ok(redirect("/profile"))
+        }
+    }
+}
+
+impl fmt::Display for Post {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let Self { author, name, timestamp, imports, runs, dependencies, code, .. } = self;
+        write_html! { f <div class="preview">
+            <div class="info">
+                <span>
+                    <a "hx-get"={format_args!("/profile-view/{author}")} href="" "hx-target"="main"
+                        "hx-push-url"={format_args!("/profile/{author}")}
+                        "hx-swam"="innerHTML">author</a>
+                    "/"
+                    name
+                </span>
+                <span apply="timestamp">timestamp</span>
+            </div>
+            <div class="stats">
+                for (name, count) in "inps runs deps".split(' ')
+                    .zip([imports, runs, dependencies])
+                    .filter(|(_, &c)| c != 0)
+                {
+                    name ": "<span>count</span>
+                }
+            </div>
+            <pre apply="fmt">code</pre>
+            if *timestamp == 0 {
+                <button "hx-get"="/post" "hx-swap"="outerHTML"
+                    "hx-target"="[preview]">"edit"</button>
+            }
+        </div> }
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+struct Profile {
+    other: Option<String>,
+}
+
+impl Profile {
+    async fn get_other(session: Session, Path(name): Path<String>) -> Html<String> {
+        Profile { other: Some(name) }.render(&session)
+    }
+
+    async fn get_other_page(session: Session, Path(name): Path<String>) -> Html<String> {
+        base(|b| Profile { other: Some(name) }.render_to_buf(&session, b), Some(&session))
+    }
+}
+
+impl Page for Profile {
+    fn render_to_buf(self, session: &Session, buf: &mut String) {
+        db::with(|db| {
+            let iter = db
+                .get_user_posts
+                .query_map((self.other.as_ref().unwrap_or(&session.name),), Post::from_row)
+                .log("get user posts query")
+                .into_iter()
+                .flatten()
+                .filter_map(|p| p.log("user post row"));
+            write_html! { (buf)
+                for post in iter {
+                    !{post}
+                } else {
+                    "no posts"
+                }
+                !{include_str!("profile-page.html")}
+            }
+        })
+    }
+}
+
+fn hash_password(password: &str) -> String {
+    use argon2::PasswordHasher;
+    argon2::Argon2::default()
+        .hash_password(password.as_bytes(), &SaltString::generate(&mut OsRng))
+        .unwrap()
+        .to_string()
+}
+
+fn verify_password(hash: &str, password: &str) -> Result<(), argon2::password_hash::Error> {
+    argon2::Argon2::default()
+        .verify_password(password.as_bytes(), &argon2::PasswordHash::new(hash)?)
+}
+
+#[derive(Serialize, Deserialize, Default, Debug)]
+struct Login {
+    name: String,
+    password: String,
+    #[serde(skip)]
+    error: Option<&'static str>,
+}
+
+impl PublicPage for Login {
+    fn render_to_buf(self, buf: &mut String) {
+        let Login { name, password, error } = self;
+        write_html! { (buf)
+            <form "hx-post"="/login" "hx-swap"="outerHTML">
+                if let Some(e) = error { <div class="error">e</div> }
+                <input name="name" type="text" autocomplete="name" placeholder="name" value=name
+                    required maxlength=MAX_NAME_LENGTH>
+                <input name="password" type="password" autocomplete="current-password" placeholder="password"
+                    value=password>
+                <input type="submit" value="submit">
+            </form>
+        }
+    }
+}
+
+impl Login {
+    async fn post(
+        axum::Form(mut data): axum::Form<Self>,
+    ) -> Result<AppendHeaders<[(&'static str, String); 2]>, Html<String>> {
+        // TODO: hash password
+        let mut id = [0u8; 32];
+        db::with(|db| match db.authenticate.query_row((&data.name,), |r| r.get::<_, String>(1)) {
+            Ok(hash) => {
+                if verify_password(&hash, &data.password).is_err() {
+                    data.error = Some("invalid credentials");
+                } else {
+                    getrandom::getrandom(&mut id).unwrap();
+                    if db
+                        .login
+                        .insert((id, &data.name, now() + SESSION_DURATION_SECS))
+                        .log("create session query")
+                        .is_none()
+                    {
+                        data.error = Some("internal server error");
+                    }
+                }
+            }
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                data.error = Some("invalid credentials");
+            }
+            Err(e) => {
+                log::error!("foo {e}");
+                data.error = Some("internal server error");
+            }
+        });
+
+        if data.error.is_some() {
+            log::error!("what {:?}", data);
+            Err(data.render())
+        } else {
+            Ok(AppendHeaders([
+                ("hx-location", "/feed".into()),
+                (
+                    "set-cookie",
+                    format!(
+                        "id={}; SameSite=Strict; Secure; Max-Age={SESSION_DURATION_SECS}",
+                        to_hex(&id)
+                    ),
+                ),
+            ]))
+        }
+    }
+
+    async fn delete(session: Session) -> Redirect {
+        _ = db::with(|q| q.logout.execute((session.id,)).log("delete session query"));
+        redirect("/login")
+    }
+}
+
+#[derive(Serialize, Deserialize, Default)]
+struct Signup {
+    name: String,
+    new_password: String,
+    confirm_password: String,
+    #[serde(default)]
+    confirm_no_password: bool,
+    #[serde(skip)]
+    error: Option<&'static str>,
+}
+
+impl PublicPage for Signup {
+    fn render_to_buf(self, buf: &mut String) {
+        let Signup { name, new_password, confirm_password, confirm_no_password, error } = self;
+        let vals = if confirm_no_password { "{\"confirm_no_password\":true}" } else { "{}" };
+        write_html! { (buf)
+            <form "hx-post"="/signup" "hx-swap"="outerHTML" "hx-vals"=vals>
+                if let Some(e) = error { <div class="error">e</div> }
+                <input name="name" type="text" autocomplete="name" placeholder="name" value=name
+                    maxlength=MAX_NAME_LENGTH required>
+                <input name="new_password" type="password" autocomplete="new-password" placeholder="new password"
+                    value=new_password>
+                <input name="confirm_password" type="password" autocomplete="confirm-password"
+                    placeholder="confirm password" value=confirm_password>
+                <input type="submit" value="submit">
+            </form>
+        }
+    }
+}
+
+impl Signup {
+    async fn post(axum::Form(mut data): axum::Form<Self>) -> Result<Redirect, Html<String>> {
+        if data.name.len() > MAX_NAME_LENGTH {
+            data.error = Some(formatcp!("name too long, max length is {MAX_NAME_LENGTH}"));
+            return Err(data.render());
+        }
+
+        if !data.confirm_no_password && data.new_password.is_empty() {
+            data.confirm_no_password = true;
+            data.error = Some("Are you sure you don't want to use a password? (then submit again)");
+            return Err(data.render());
+        }
+
+        db::with(|db| {
+            // TODO: hash passwords
+            match db.register.insert((&data.name, hash_password(&data.new_password))) {
+                Ok(_) => {}
+                Err(rusqlite::Error::SqliteFailure(e, _))
+                    if e.code == rusqlite::ErrorCode::ConstraintViolation =>
+                {
+                    data.error = Some("username already taken");
+                }
+                Err(e) => {
+                    log::error!("create user query: {e}");
+                    data.error = Some("internal server error");
+                }
+            };
+        });
+
+        if data.error.is_some() {
+            Err(data.render())
+        } else {
+            Ok(redirect("/login"))
+        }
+    }
+}
+
+fn base(body: impl FnOnce(&mut String), session: Option<&Session>) -> Html<String> {
+    let username = session.map(|s| &s.name);
+
+    let nav_button = |f: &mut String, name: &str| {
+        write_html! {(f)
+            <button "hx-push-url"={format_args!("/{name}")}
+                "hx-get"={format_args!("/{name}-view")}
+                "hx-target"="main"
+                "hx-swap"="innerHTML">name</button>
+        }
+    };
+
+    Html(html! {
+        "<!DOCTYPE html>"
+        <html lang="en">
+            <head>
+                <meta name="charset" content="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1">
+                <link rel="stylesheet" href="/index.css">
+            </head>
+            <body>
+                <nav>
+                    <button "hx-push-url"="/" "hx-get"="/index-view" "hx-target"="main" "hx-swap"="innerHTML">"depell"</button>
+                    <section>
+                        if let Some(username) = username {
+                            <button "hx-push-url"="/profile" "hx-get"="/profile-view" "hx-target"="main"
+                                "hx-swap"="innerHTML">username</button>
+                            |f|{nav_button(f, "feed"); nav_button(f, "post")}
+                            <button "hx-delete"="/login">"logout"</button>
+                        } else {
+                            |f|{nav_button(f, "login"); nav_button(f, "signup")}
+                        }
+                    </section>
+                </nav>
+                <section id="post-form"></section>
+                <main>|f|{body(f)}</main>
+            </body>
+            <script src="https://unpkg.com/htmx.org@2.0.3/dist/htmx.min.js" integrity="sha384-0895/pl2MU10Hqc6jd4RvrthNlDiE9U1tWmX7WRESftEDRosgxNsQG/Ze9YMRzHq" crossorigin="anonymous"></script>
+            <script type="module" src="/index.js"></script>
+        </html>
+    })
+}
+
+struct Session {
+    name: String,
+    id: [u8; 32],
+}
+
+#[axum::async_trait]
+impl<S> axum::extract::FromRequestParts<S> for Session {
+    /// If the extractor fails it'll use this "rejection" type. A rejection is
+    /// a kind of error that can be converted into a response.
+    type Rejection = Redirect;
+
+    /// Perform the extraction.
+    async fn from_request_parts(parts: &mut Parts, _: &S) -> Result<Self, Self::Rejection> {
+        let err = redirect("/login");
+
+        let value = parts
+            .headers
+            .get_all(COOKIE)
+            .into_iter()
+            .find_map(|c| c.to_str().ok()?.trim().strip_prefix("id="))
+            .map(|c| c.split_once(';').unwrap_or((c, "")).0)
+            .ok_or(err)?;
+        let mut id = [0u8; 32];
+        parse_hex(value, &mut id).ok_or(err)?;
+
+        let (name, expiration) = db::with(|db| {
+            db.get_session
+                .query_row((id,), |r| Ok((r.get::<_, String>(0)?, r.get::<_, u64>(1)?)))
+                .log("fetching session")
+                .ok_or(err)
+        })?;
+
+        if expiration < now() {
+            return Err(err);
+        }
+
+        Ok(Self { name, id })
+    }
+}
+
+fn now() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)
+        .unwrap()
+        .as_secs()
+}
+
+fn parse_hex(hex: &str, dst: &mut [u8]) -> Option<()> {
+    fn hex_to_nibble(b: u8) -> Option<u8> {
+        Some(match b {
+            b'a'..=b'f' => b - b'a' + 10,
+            b'A'..=b'F' => b - b'A' + 10,
+            b'0'..=b'9' => b - b'0',
+            _ => return None,
+        })
+    }
+
+    if hex.len() != dst.len() * 2 {
+        return None;
+    }
+
+    for (d, p) in dst.iter_mut().zip(hex.as_bytes().chunks_exact(2)) {
+        *d = (hex_to_nibble(p[0])? << 4) | hex_to_nibble(p[1])?;
+    }
+
+    Some(())
+}
+
+fn to_hex(src: &[u8]) -> String {
+    use std::fmt::Write;
+    let mut buf = String::new();
+    for &b in src {
+        write!(buf, "{b:02x}").unwrap()
+    }
+    buf
+}
+
+fn main() {
+    tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(amain());
+}
+
+mod db {
+    use std::cell::RefCell;
+
+    macro_rules! gen_queries {
+        ($vis:vis struct $name:ident {
+            $($qname:ident: $code:expr,)*
+        }) => {
+            $vis struct $name<'a> {
+                $($vis $qname: rusqlite::Statement<'a>,)*
+            }
+
+            impl<'a> $name<'a> {
+                fn new(db: &'a rusqlite::Connection) -> Self {
+                    Self {
+                        $($qname: db.prepare($code).unwrap(),)*
+                    }
+                }
+            }
+        };
+    }
+
+    gen_queries! {
+        pub struct Queries {
+            register: "INSERT INTO user (name, password_hash) VALUES(?, ?)",
+            authenticate: "SELECT name, password_hash FROM user WHERE name = ?",
+            login: "INSERT OR REPLACE INTO session (id, username, expiration) VALUES(?, ?, ?)",
+            logout: "DELETE FROM session WHERE id = ?",
+            get_session: "SELECT username, expiration FROM session WHERE id = ?",
+            get_user_posts: "SELECT author, name, timestamp, code FROM post WHERE author = ?
+                ORDER BY timestamp DESC",
+            get_pots_before: "SELECT author, name, timestamp, code FROM post WHERE timestamp < ?",
+            create_post: "INSERT INTO post (name, author, timestamp, code) VALUES(?, ?, ?, ?)",
+            fetch_deps: "
+                WITH RECURSIVE roots(name, author, code) AS (
+                    SELECT name, author, code FROM post WHERE name = ? AND author = ?
+                    UNION
+                    SELECT post.name, post.author, post.code FROM
+                        post JOIN import ON post.name = import.to_name
+                            AND post.author = import.to_author
+                        JOIN roots ON import.from_name = roots.name
+                            AND import.from_author = roots.author
+                ) SELECT * FROM roots;
+            ",
+            create_import: "INSERT INTO import(to_author, to_name, from_author, from_name)
+                VALUES(?, ?, ?, ?)",
+        }
+    }
+
+    struct Db {
+        queries: Queries<'static>,
+        _db: Box<rusqlite::Connection>,
+    }
+
+    impl Db {
+        fn new() -> Self {
+            let db = Box::new(rusqlite::Connection::open("db.sqlite").unwrap());
+            Self {
+                queries: Queries::new(unsafe {
+                    std::mem::transmute::<&rusqlite::Connection, &rusqlite::Connection>(&db)
+                }),
+                _db: db,
+            }
+        }
+    }
+
+    pub fn with<T>(with: impl FnOnce(&mut Queries) -> T) -> T {
+        thread_local! { static DB_CONN: RefCell<Db> = RefCell::new(Db::new()); }
+        DB_CONN.with_borrow_mut(|q| with(&mut q.queries))
+    }
+
+    pub fn init() {
+        let db = rusqlite::Connection::open("db.sqlite").unwrap();
+        db.execute_batch(include_str!("schema.sql")).unwrap();
+        Queries::new(&db);
+    }
+}
+
+fn redirect(to: &'static str) -> Redirect {
+    AppendHeaders([("hx-location", to)])
+}
+
+trait PublicPage: Default {
+    fn render_to_buf(self, buf: &mut String);
+
+    fn render(self) -> Html<String> {
+        let mut str = String::new();
+        self.render_to_buf(&mut str);
+        Html(str)
+    }
+
+    async fn get() -> Html<String> {
+        Self::default().render()
+    }
+
+    async fn page(session: Option<Session>) -> Html<String> {
+        base(|s| Self::default().render_to_buf(s), session.as_ref())
+    }
+}
+
+trait Page: Default {
+    fn render_to_buf(self, session: &Session, buf: &mut String);
+
+    fn render(self, session: &Session) -> Html<String> {
+        let mut str = String::new();
+        self.render_to_buf(session, &mut str);
+        Html(str)
+    }
+
+    async fn get(session: Session) -> Html<String> {
+        Self::default().render(&session)
+    }
+
+    async fn page(session: Option<Session>) -> Result<Html<String>, axum::response::Redirect> {
+        match session {
+            Some(session) => {
+                Ok(base(|f| Self::default().render_to_buf(&session, f), Some(&session)))
+            }
+            None => Err(axum::response::Redirect::permanent("/login")),
+        }
+    }
+}
+
+trait ResultExt<O, E> {
+    fn log(self, prefix: impl Display) -> Option<O>;
+}
+
+impl<O, E: Display> ResultExt<O, E> for Result<O, E> {
+    fn log(self, prefix: impl Display) -> Option<O> {
+        match self {
+            Ok(v) => Some(v),
+            Err(e) => {
+                log::error!("{prefix}: {e}");
+                None
+            }
+        }
+    }
+}
+
+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.module_path().unwrap_or("=="), record.args());
+        }
+    }
+
+    fn flush(&self) {}
+}

depell/src/post-page.html

@@ -0,0 +1,21 @@
+<div id="dep-list">
+	<input placeholder="search impoted deps.." oninput="filterCodeDeps(this, event)">
+	<section id="deps">
+		results show here...
+	</section>
+</div>
+
+<div>
+
+	<h3>About posting code</h3>
+	<p>
+		If you are unfammiliar with <a href="https://git.ablecorp.us/AbleOS/holey-bytes">hblang</a>, refer to the
+		<strong>hblang/README.md</strong> or
+		vizit <a href="/profile/mlokis">mlokis'es posts</a>. Preferably don't edit the code here.
+	</p>
+
+	<h3>Extra textarea features</h3>
+	<ul>
+		<li>proper tab behaviour</li>
+		<li>snap to previous tab boundary on "empty" lines</li>
+	</ul>

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/welcome-page.html

@@ -0,0 +1,17 @@
+<h1>Welcome to depell</h1>
+<p>
+	Depell (dependency hell) is a simple "social" media site best compared to twitter, except that all you can post is
+	<a href="https://git.ablecorp.us/AbleOS/holey-bytes">hblang</a> code with no comments allowed. Instead of likes you
+	run the program, and instead of retweets you import the program as dependency. Run counts even when ran indirectly.
+</p>
+
+<p>
+	The backend only serves the code and frontend compiles and runs it locally. All posts are immutable.
+</p>
+
+<h2>Security?</h2>
+<p>
+	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.
+</p>

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,34 @@
+#![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 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,111 @@
+#![feature(alloc_error_handler)]
+#![feature(slice_take)]
+#![no_std]
+
+use {
+    alloc::{string::String, vec::Vec},
+    hblang::{
+        parser::FileId,
+        son::{Codegen, CodegenCtx},
+    },
+};
+
+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 files = {
+        let mut ctx = hblang::parser::Ctx::default();
+        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() as FileId),
+            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,
+                    &mut loader,
+                )
+            })
+            .collect::<Vec<_>>()
+    };
+
+    let mut ct = {
+        let mut ctx = CodegenCtx::default();
+        let mut c = Codegen::new(&files, &mut ctx);
+        c.generate(root as FileId);
+        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 unknown = ct.vm.read_reg(2).0;
+                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/asm/hello-name.hba

@@ -0,0 +1,100 @@
+jmp entry
+
+puts:
+-- Write string to console
+--  r2: [IN] *const u8  String pointer
+--  r3: [IN] usize      String length
+
+    li8     r1, 0x1         -- Write syscall
+    brc     r2, r3, 2       -- Copy parameters
+    li8     r2, 0x1         -- STDOUT
+    eca
+
+    jal     r0, r31, 0
+
+gets:
+-- Read string until end of buffer or LF
+--  r2: [IN] *mut u8    Buffer
+--  r3: [IN] usize      Buffer length
+
+    -- Register allocations:
+    --  r33: *mut u8    Buffer end
+    --  r34: u8         Immediate char
+    --  r35: u8         Const [0x0A = LF]
+
+    li8     r35, 0x0A
+    add64   r33, r2, r3
+
+    -- Setup syscall
+    li8     r2, 0x1         -- Stdin
+    cp      r3, r2
+    li8     r4, 0x1         -- Read one char
+
+    jeq     r3, r33, end
+    loop:
+        li8     r1, 0x1     -- Read syscall
+        eca
+        addi64  r3, r3, 1
+        ld      r34, r3, 0, 1
+        jeq     r34, r35, end
+        jne     r3, r33, loop
+    
+    end:
+        -- Set copied amount
+        sub64   r1, r33, r3
+        addi64  r1, -1
+        jal     r0, r31, 0
+
+alloc-pages:
+-- Allocate pages
+--  r1: [OUT] *mut u8   Pointer to page
+--  r2: [IN]  u16       Page count
+
+    muli16  r3, r2, 4096    -- page count
+    li8     r1, 0x9         -- mmap syscall
+    li8     r2, 0x0         -- no address set, kernel chosen
+    li8     r4, 0x2         -- PROT_WRITE
+    li8     r5, 0x20        -- MAP_ANONYMOUS
+    li64    r6, -1          -- Doesn't map file
+    li8     r7, 0x0         -- Doesn't map file
+    eca
+
+    jal     r0, r31, 0
+
+entry:
+-- Program entrypoint
+
+    -- Register allocations:
+    -- r32: *mut u8     Buffer
+    -- r36: usize       Read buffer length
+
+    -- Allocate one page (4096 KiB)
+    li8     r2, 1
+    jal     r31, 0, alloc-pages
+    cp      r32, r1
+
+    -- Print message
+    lra16   r2, r0, #enter-your-name
+    li8     r3, 17
+    jal     r31, r0, puts
+
+    -- Read name
+    cp      r2, r32
+    li16    r3, 4096
+    jal     r31, r0, gets
+    cp      r36, r1
+
+    -- Print your name is
+    lra16   r2, r0, #your-name-is
+    li8     r3, 15
+    jal     r31, r0, puts
+
+    -- And now print the name
+    cp      r2, r32
+    cp      r3, r36
+    jal     r31, r0, puts
+
+    tx
+
+#enter-your-name: "Enter your name: "
+#your-name-is   : "\nYour name is: "

f.txt

@@ -0,0 +1,47 @@
+start: 0
+  46-c65535:    +:       [0, 38, 45]    [47]
+  45-c65535:    &:       [0, 43, 44]    [46]
+  44-c65535: cint: #255  [0]            [45]
+  43-c65535: load:       [0, 42, 23]    [45]
+  42-c65535:    +:       [0, 22, 18]    [43]
+  39-c65535: stre:       [0, 0, 36, 37] [47]
+  39-c65535: stre:       [0, 0, 36, 37] [47]
+  37-c65535: stre:       [0, 35, 36, 3] [38, 39]
+  36-c65535: stck:       [0, 3]         [37, 38, 39]
+  35-c65535: load:       [0, 24, 34]    [37]
+  34-c65535: stre:       [0, 31, 33, 30] [35, 47]
+  33-c65535:    +:       [0, 24, 32]    [34]
+  32-c65535: cint: #16   [0]            [33]
+  31-c65535: cint: #4    [0]            [34]
+  30-c65535: stre:       [0, 27, 29, 26] [34]
+  29-c65535:    +:       [0, 24, 28]    [30]
+  28-c65535: cint: #8    [0]            [29]
+  27-c65535: cint: #2    [0]            [30]
+  26-c65535: stre:       [0, 25, 24, 3] [30]
+  25-c65535: cint: #1    [0]            [26]
+  24-c65535: stck:       [0, 3]         [26, 29, 33, 35]
+  23-c65535: stre:       [0, 21, 22, 3] [43, 47]
+  22-c65535: stck:       [0, 3]         [23, 42]
+  21-c65535: load:       [0, 6, 20]     [23]
+  20-c65535: stre:       [0, 17, 19, 14] [21, 47]
+  19-c65535:    +:       [0, 6, 18]     [20]
+  18-c65535: cint: #3    [0]            [19, 42]
+  17-c65535: cint: #1    [0]            [20]
+  14-c65535: stre:       [0, 5, 13, 11] [20]
+  13-c65535:    +:       [0, 6, 12]     [14]
+  12-c65535: cint: #2    [0]            [13]
+  11-c65535: stre:       [0, 7, 10, 8]  [14]
+  10-c65535:    +:       [0, 6, 9]      [11]
+   9-c65535: cint: #1    [0]            [10]
+   8-c65535: stre:       [0, 7, 6, 3]   [11]
+   7-c65535: cint: #0    [0]            [8, 11]
+   6-c65535: stck:       [0, 3]         [8, 10, 13, 19, 21]
+   5-c65535: cint: #511  [0]            [14]
+   4-c65535:  loops:       [0]            []
+   3-c65535:  mem:       [0]            [6, 8, 22, 23, 24, 26, 36, 37, 47]
+   2-c65535: ctrl: entry [0]            [38]
+b2: 0 0 [38]
+  38-c65535: call: 1 0   [2, 36, 37]    [46, 47]
+  47-c65535:  ret:       [38, 46, 3, 20, 23, 34, 39] [1]
+
+

f1.txt

@@ -0,0 +1,38 @@
+
+start: 0
+  34-c65535: stre:       [0, 31, 51, 30] [39, 47, 38]
+  51-c65535:    +:       [0, 36, 32]    [34]
+  32-c65535: cint: #16   [0]            [51]
+  31-c65535: cint: #4    [0]            [34]
+  30-c65535: stre:       [0, 27, 50, 26] [34]
+  50-c65535:    +:       [0, 36, 28]    [30]
+  28-c65535: cint: #8    [0]            [50]
+  27-c65535: cint: #2    [0]            [30]
+  26-c65535: stre:       [0, 25, 36, 3] [30]
+  25-c65535: cint: #1    [0]            [26, 46]
+  39-c65535: stre:       [0, 0, 36, 34] [47]
+  36-c65535: stck:       [0, 3]         [51, 38, 39, 26, 50]
+  22-c65535: stck:       [0, 3]         [49, 42, 8, 48]
+  39-c65535: stre:       [0, 0, 36, 34] [47]
+  20-c65535: stre:       [0, 17, 42, 14] [47, 47]
+  46-c65535:    +:       [0, 38, 25]    [47]
+  18-c65535: cint: #3    [0]            [42]
+  17-c65535: cint: #1    [0]            [20]
+  14-c65535: stre:       [0, 5, 49, 11] [20]
+  49-c65535:    +:       [0, 22, 12]    [14]
+  12-c65535: cint: #2    [0]            [49]
+  11-c65535: stre:       [0, 7, 48, 8]  [14]
+  48-c65535:    +:       [0, 22, 9]     [11]
+   9-c65535: cint: #1    [0]            [48]
+   8-c65535: stre:       [0, 7, 22, 3]  [11]
+   7-c65535: cint: #0    [0]            [8, 11]
+  42-c65535:    +:       [0, 22, 18]    [20]
+   5-c65535: cint: #511  [0]            [14]
+   4-c65535:  loops:       [0]            []
+   3-c65535:  mem:       [0]            [47, 8, 22, 26, 36]
+   2-c65535: ctrl: entry [0]            [38]
+b2: 0 0 [38]
+  38-c65535: call: 1 0   [2, 36, 34]    [46, 47]
+  47-c65535:  ret:       [38, 46, 3, 20, 20, 34, 39] [1]
+
+

f2.txt

@@ -0,0 +1,39 @@
+start: 0
+  42-c65535:    +:       [0, 22, 18]    [43, 20]
+  36-c65535: stck:       [0, 3]         [51, 38, 39, 26, 50]
+  39-c65535: stre:       [0, 0, 36, 34] [47]
+  34-c65535: stre:       [0, 31, 51, 30] [39, 47, 38]
+  51-c65535:    +:       [0, 36, 32]    [34]
+  32-c65535: cint: #16   [0]            [51]
+  31-c65535: cint: #4    [0]            [34]
+  30-c65535: stre:       [0, 27, 50, 26] [34]
+  50-c65535:    +:       [0, 36, 28]    [30]
+  28-c65535: cint: #8    [0]            [50]
+  27-c65535: cint: #2    [0]            [30]
+  26-c65535: stre:       [0, 25, 36, 3] [30]
+  25-c65535: cint: #1    [0]            [26]
+  39-c65535: stre:       [0, 0, 36, 34] [47]
+  45-c65535:    &:       [0, 43, 44]    [46]
+  22-c65535: stck:       [0, 3]         [49, 42, 8, 48]
+  44-c65535: cint: #255  [0]            [45]
+  20-c65535: stre:       [0, 17, 42, 14] [47, 47, 43]
+  46-c65535:    +:       [0, 38, 45]    [47]
+  18-c65535: cint: #3    [0]            [42]
+  17-c65535: cint: #1    [0]            [20]
+  14-c65535: stre:       [0, 5, 49, 11] [20]
+  49-c65535:    +:       [0, 22, 12]    [14]
+  12-c65535: cint: #2    [0]            [49]
+  11-c65535: stre:       [0, 7, 48, 8]  [14]
+  48-c65535:    +:       [0, 22, 9]     [11]
+   9-c65535: cint: #1    [0]            [48]
+   8-c65535: stre:       [0, 7, 22, 3]  [11]
+   7-c65535: cint: #0    [0]            [8, 11]
+  43-c65535: load:       [0, 42, 20]    [45]
+   5-c65535: cint: #511  [0]            [14]
+   4-c65535:  loops:       [0]            []
+   3-c65535:  mem:       [0]            [47, 8, 22, 26, 36]
+   2-c65535: ctrl: entry [0]            [38]
+b2: 0 0 [38]
+  38-c65535: call: 1 0   [2, 36, 34]    [46, 47]
+  47-c65535:  ret:       [38, 46, 3, 20, 20, 34, 39] [1]
+

hbvm/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "hbvm"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-log = "*"
-hashbrown = "0.13.2"

hbvm/src/bytecode/mod.rs

@@ -1,2 +0,0 @@
-pub mod ops;
-pub mod types;

hbvm/src/bytecode/ops.rs

@@ -1,68 +0,0 @@
-#[repr(u8)]
-pub enum Operations {
-    NOP = 0,
-
-    ADD = 1,
-    SUB = 2,
-    MUL = 3,
-    DIV = 4,
-    MOD = 5,
-
-    AND = 6,
-    OR = 7,
-    XOR = 8,
-    NOT = 9,
-
-    // LOADs a memory address/constant into a register
-    LOAD = 15,
-    // STOREs a register/constant into a memory address
-    STORE = 16,
-
-    MapPage = 17,
-    UnmapPage = 18,
-
-    // SHIFT LEFT 16 A0
-    Shift = 20,
-
-    JUMP = 100,
-    JumpCond = 101,
-    RET = 103,
-
-    EnviromentCall = 255,
-}
-
-pub enum PageMapTypes {
-    // Have the host make a new VMPage
-    VMPage = 0,
-    // Ask the host to map a RealPage into memory
-    RealPage = 1,
-}
-
-pub enum MathOpSubTypes {
-    Unsigned = 0,
-    Signed = 1,
-    FloatingPoint = 2,
-}
-
-pub enum MathOpSides {
-    RegisterConstant = 0,
-    RegisterRegister = 1,
-    ConstantConstant = 2,
-    ConstantRegister = 3,
-}
-
-pub enum RWSubTypes {
-    AddrToReg = 0,
-    RegToAddr,
-    ConstToReg,
-    ConstToAddr,
-}
-
-pub enum JumpConditionals {
-    Equal = 0,
-    NotEqual = 1,
-    LessThan = 2,
-    LessThanOrEqualTo = 3,
-    GreaterThan = 4,
-    GreaterThanOrEqualTo = 5,
-}

hbvm/src/bytecode/types.rs

@@ -1,9 +0,0 @@
-
-pub const CONST_U8: u8 = 0x00;
-pub const CONST_I8: i8 = 0x01;
-
-pub const CONST_U64: u8 = 0x02;
-pub const CONST_I64: u8 = 0x03;
-pub const CONST_F64: u8 = 0x04;
-
-pub const ADDRESS: u8 = 0x05;

hbvm/src/engine/call_stack.rs

@@ -1,6 +0,0 @@
-use alloc::vec::Vec;
-
-pub type CallStack = Vec<FnCall>;
-pub struct FnCall {
-    pub ret: usize,
-}

hbvm/src/engine/config.rs

@@ -1,13 +0,0 @@
-pub struct EngineConfig {
-    pub call_stack_depth: usize,
-    pub quantum: u32,
-}
-
-impl EngineConfig {
-    pub fn default() -> Self {
-        Self {
-            call_stack_depth: 32,
-            quantum: 0,
-        }
-    }
-}

hbvm/src/engine/enviroment_calls.rs

@@ -1,3 +0,0 @@
-use super::Engine;
-
-pub type EnviromentCall = fn(&mut Engine) -> Result<&mut Engine, u64>;

hbvm/src/engine/mod.rs

@@ -1,100 +0,0 @@
-pub mod call_stack;
-pub mod config;
-pub mod enviroment_calls;
-pub mod regs;
-#[cfg(test)]
-pub mod tests;
-
-use {
-    self::call_stack::CallStack,
-    crate::{memory, HaltStatus, RuntimeErrors},
-    alloc::vec::Vec,
-    config::EngineConfig,
-    log::trace,
-    regs::Registers,
-};
-// pub const PAGE_SIZE: usize = 8192;
-
-pub struct RealPage {
-    pub ptr: *mut u8,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub struct VMPage {
-    pub data: [u8; 8192],
-}
-impl VMPage {
-    pub fn new() -> Self {
-        Self {
-            data: [0; 4096 * 2],
-        }
-    }
-}
-
-pub enum Page {
-    VMPage(VMPage),
-    RealPage(RealPage),
-}
-impl Page {
-    pub fn data(&self) -> [u8; 4096 * 2] {
-        match self {
-            Page::VMPage(vmpage) => vmpage.data,
-            Page::RealPage(_) => {
-                unimplemented!("Memmapped hw page not yet supported")
-            }
-        }
-    }
-}
-
-pub fn empty_enviroment_call(engine: &mut Engine) -> Result<&mut Engine, u64> {
-    trace!("Registers {:?}", engine.registers);
-    Err(0)
-}
-
-pub struct Engine {
-    pub index:     usize,
-    pub program:   Vec<u8>,
-    pub registers: Registers,
-    pub config:    EngineConfig,
-
-    /// BUG: This DOES NOT account for overflowing
-    pub last_timer_count: u32,
-    pub timer_callback: Option<fn() -> u32>,
-    pub memory: memory::Memory,
-    pub enviroment_call_table: [Option<EnviromentCall>; 256],
-    pub call_stack: CallStack,
-}
-use crate::engine::enviroment_calls::EnviromentCall;
-impl Engine {
-    pub fn set_timer_callback(&mut self, func: fn() -> u32) {
-        self.timer_callback = Some(func);
-    }
-    pub fn set_register(&mut self, register: u8, value: u64) {}
-}
-
-impl Engine {
-    pub fn new(program: Vec<u8>) -> Self {
-        let mut mem = memory::Memory::new();
-        for (addr, byte) in program.clone().into_iter().enumerate() {
-            let _ = mem.set_addr8(addr as u64, byte);
-        }
-        trace!("{:?}", mem.read_addr8(0));
-        let ecall_table: [Option<EnviromentCall>; 256] = [None; 256];
-        Self {
-            index: 0,
-            program,
-            registers: Registers::new(),
-            config: EngineConfig::default(),
-            last_timer_count: 0,
-            timer_callback: None,
-            enviroment_call_table: ecall_table,
-            memory: mem,
-            call_stack: Vec::new(),
-        }
-    }
-
-    pub fn dump(&self) {}
-    pub fn run(&mut self) -> Result<HaltStatus, RuntimeErrors> {
-        Ok(HaltStatus::Halted)
-    }
-}

hbvm/src/engine/regs.rs

@@ -1,32 +0,0 @@
-#[rustfmt::skip]
-#[derive(Debug, Clone, Copy)]
-pub struct Registers {
-    pub a0: u64, pub b0: u64, pub c0: u64, pub d0: u64, pub e0: u64, pub f0: u64,
-    pub a1: u64, pub b1: u64, pub c1: u64, pub d1: u64, pub e1: u64, pub f1: u64,
-    pub a2: u64, pub b2: u64, pub c2: u64, pub d2: u64, pub e2: u64, pub f2: u64,
-    pub a3: u64, pub b3: u64, pub c3: u64, pub d3: u64, pub e3: u64, pub f3: u64,
-    pub a4: u64, pub b4: u64, pub c4: u64, pub d4: u64, pub e4: u64, pub f4: u64,
-    pub a5: u64, pub b5: u64, pub c5: u64, pub d5: u64, pub e5: u64, pub f5: u64,
-    pub a6: u64, pub b6: u64, pub c6: u64, pub d6: u64, pub e6: u64, pub f6: u64,
-    pub a7: u64, pub b7: u64, pub c7: u64, pub d7: u64, pub e7: u64, pub f7: u64,
-    pub a8: u64, pub b8: u64, pub c8: u64, pub d8: u64, pub e8: u64, pub f8: u64,
-    pub a9: u64, pub b9: u64, pub c9: u64, pub d9: u64, pub e9: u64, pub f9: u64,
-}
-
-impl Registers {
-    #[rustfmt::skip]
-    pub fn new() -> Self{
-        Self {
-            a0: 0, b0: 0, c0: 0, d0: 0, e0: 0, f0: 0,
-            a1: 0, b1: 0, c1: 0, d1: 0, e1: 0, f1: 0,
-            a2: 0, b2: 0, c2: 0, d2: 0, e2: 0, f2: 0,
-            a3: 0, b3: 0, c3: 0, d3: 0, e3: 0, f3: 0,
-            a4: 0, b4: 0, c4: 0, d4: 0, e4: 0, f4: 0,
-            a5: 0, b5: 0, c5: 0, d5: 0, e5: 0, f5: 0,
-            a6: 0, b6: 0, c6: 0, d6: 0, e6: 0, f6: 0,
-            a7: 0, b7: 0, c7: 0, d7: 0, e7: 0, f7: 0,
-            a8: 0, b8: 0, c8: 0, d8: 0, e8: 0, f8: 0,
-            a9: 0, b9: 0, c9: 0, d9: 0, e9: 0, f9: 0,
-        }
-    }
-}

hbvm/src/engine/tests/mod.rs

@@ -1,125 +0,0 @@
-use {
-    super::Engine,
-    crate::{HaltStatus, RuntimeErrors},
-    alloc::vec,
-    RuntimeErrors::*,
-};
-
-#[test]
-fn invalid_program() {
-    let prog = vec![1, 0];
-    let mut eng = Engine::new(prog);
-    let ret = eng.run();
-    assert_eq!(ret, Err(InvalidOpcodePair(1, 0)));
-}
-
-#[test]
-fn empty_program() {
-    let prog = vec![];
-    let mut eng = Engine::new(prog);
-    let ret = eng.run();
-    assert_eq!(ret, Ok(HaltStatus::Halted));
-}
-
-#[test]
-fn max_quantum_reached() {
-    let prog = vec![0, 0, 0, 0];
-    let mut eng = Engine::new(prog);
-    eng.set_timer_callback(|| {
-        return 1;
-    });
-    eng.config.quantum = 1;
-    let ret = eng.run();
-    assert_eq!(ret, Ok(HaltStatus::Running));
-}
-
-#[test]
-fn jump_out_of_bounds() {
-    use crate::bytecode::ops::Operations::JUMP;
-    let prog = vec![JUMP as u8, 0, 0, 0, 0, 0, 0, 1, 0];
-    let mut eng = Engine::new(prog);
-    let ret = eng.run();
-    assert_eq!(ret, Err(InvalidJumpAddress(256)));
-}
-
-#[test]
-fn invalid_system_call() {
-    let prog = vec![255, 0];
-    let mut eng = Engine::new(prog);
-    let ret = eng.run();
-    assert_eq!(ret, Err(InvalidSystemCall(0)));
-}
-
-#[test]
-fn add_u8() {
-    use crate::bytecode::ops::{MathOpSides::ConstantConstant, Operations::ADD};
-
-    let prog = vec![ADD as u8, ConstantConstant as u8, 100, 98, 0xA0];
-    let mut eng = Engine::new(prog);
-    let _ = eng.run();
-    assert_eq!(eng.registers.a0, 2);
-}
-
-#[test]
-fn sub_u8() {
-    use crate::bytecode::ops::Operations::SUB;
-
-    let prog = vec![SUB as u8];
-    let mut eng = Engine::new(prog);
-    let _ = eng.run();
-    assert_eq!(eng.registers.a0, 1);
-}
-#[test]
-fn mul_u8() {
-    use crate::bytecode::ops::{MathOpSides::ConstantConstant, Operations::MUL};
-
-    let prog = vec![MUL as u8, ConstantConstant as u8, 1, 2, 0xA0];
-    let mut eng = Engine::new(prog);
-    let _ = eng.run();
-    assert_eq!(eng.registers.a0, 2);
-}
-
-#[test]
-fn div_u8() {
-    use crate::bytecode::ops::Operations::DIV;
-
-    let prog = vec![DIV as u8];
-    let mut eng = Engine::new(prog);
-    let _ = eng.run();
-    assert_eq!(eng.registers.a0, 2);
-}
-
-#[test]
-fn set_register() {
-    let prog = alloc::vec![];
-    let mut eng = Engine::new(prog);
-    eng.set_register(0xA0, 1);
-    assert_eq!(eng.registers.a0, 1);
-}
-
-#[test]
-fn load_u8() {
-    use crate::bytecode::ops::{Operations::LOAD, RWSubTypes::AddrToReg};
-
-    let prog = vec![LOAD as u8, AddrToReg as u8, 0, 0, 0, 0, 0, 0, 1, 0, 0xA0];
-    let mut eng = Engine::new(prog);
-    let ret = eng.memory.set_addr8(256, 1);
-    assert_eq!(ret, Ok(()));
-    let _ = eng.run();
-    assert_eq!(eng.registers.a0, 1);
-}
-#[test]
-fn set_memory_8() {
-    let prog = vec![];
-    let mut eng = Engine::new(prog);
-    let ret = eng.memory.set_addr8(256, 1);
-    assert_eq!(ret, Ok(()));
-}
-
-#[test]
-fn set_memory_64() {
-    let prog = vec![];
-    let mut eng = Engine::new(prog);
-    let ret = eng.memory.set_addr64(256, 1);
-    assert_eq!(ret, Ok(()));
-}

hbvm/src/lib.rs

@@ -1,23 +0,0 @@
-#![no_std]
-extern crate alloc;
-
-pub mod bytecode;
-pub mod engine;
-pub mod memory;
-
-#[derive(Debug, PartialEq)]
-pub enum RuntimeErrors {
-    InvalidOpcodePair(u8, u8),
-    RegisterTooSmall,
-    HostError(u64),
-    PageNotMapped(u64),
-    InvalidJumpAddress(u64),
-    InvalidSystemCall(u8),
-}
-
-// If you solve the halting problem feel free to remove this
-#[derive(PartialEq, Debug)]
-pub enum HaltStatus {
-    Halted,
-    Running,
-}

hbvm/src/main.rs

@@ -1,31 +0,0 @@
-use hbvm::{
-    bytecode::ops::{Operations::*, RWSubTypes::*},
-    engine::Engine,
-    RuntimeErrors,
-};
-
-fn main() -> Result<(), RuntimeErrors> {
-    // TODO: Grab program from cmdline
-    #[rustfmt::skip]
-        let prog: Vec<u8> = vec![
-            NOP as u8,            
-            JUMP as u8, 0, 0, 0, 0, 0, 0, 0, 0,
-        ];
-
-    let mut eng = Engine::new(prog);
-    // eng.set_timer_callback(time);
-    eng.enviroment_call_table[10] = Some(print_fn);
-    eng.run()?;
-    eng.dump();
-    println!("{:#?}", eng.registers);
-
-    Ok(())
-}
-
-pub fn time() -> u32 {
-    9
-}
-pub fn print_fn(engine: &mut Engine) -> Result<&mut Engine, u64> {
-    println!("hello");
-    Ok(engine)
-}

hbvm/src/memory.rs

@@ -1,70 +0,0 @@
-use crate::engine::VMPage;
-
-use {
-    crate::{engine::Page, RuntimeErrors},
-    alloc::vec::Vec,
-    hashbrown::HashMap,
-    log::trace,
-};
-
-pub struct Memory {
-    inner: HashMap<u64, Page>,
-}
-
-impl Memory {
-    pub fn new() -> Self {
-        Self {
-            inner: HashMap::new(),
-        }
-        //
-    }
-
-    pub fn map_vec(&mut self, address: u64, vec: Vec<u8>) {
-        panic!("Mapping vectors into pages is not supported yet");
-    }
-}
-
-impl Memory {
-    pub fn read_addr8(&mut self, address: u64) -> Result<u8, RuntimeErrors> {
-        let (page, offset) = addr_to_page(address);
-        trace!("page {} offset {}", page, offset);
-        match self.inner.get(&page) {
-            Some(page) => {
-                let val = page.data()[offset as usize];
-                trace!("Value {}", val);
-                Ok(val)
-            }
-            None => {
-                trace!("page not mapped");
-                Err(RuntimeErrors::PageNotMapped(page))
-            }
-        }
-    }
-    pub fn read_addr64(&mut self, address: u64) -> u64 {
-        unimplemented!()
-    }
-
-    pub fn set_addr8(&mut self, address: u64, value: u8) -> Result<(), RuntimeErrors> {
-        let (page, offset) = addr_to_page(address);
-        let ret: Option<(&u64, &mut Page)> = self.inner.get_key_value_mut(&page);
-        match ret {
-            Some((_, page)) => {
-                page.data()[offset as usize] = value;
-            }
-            None => {
-                let mut pg = VMPage::new();
-                pg.data[offset as usize] = value;
-                self.inner.insert(page, Page::VMPage(pg));
-                trace!("Mapped page {}", page);
-            }
-        }
-        Ok(())
-    }
-    pub fn set_addr64(&mut self, address: u64, value: u64) -> Result<(), RuntimeErrors> {
-        unimplemented!()
-    }
-}
-
-fn addr_to_page(addr: u64) -> (u64, u64) {
-    (addr / 8192, addr % 8192)
-}

lang/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "hblang"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "hbc"
+path = "src/main.rs"
+
+[[bin]]
+name = "fuzz"
+path = "src/fuzz_main.rs"
+
+[dependencies]
+hashbrown = { version = "0.15.0", default-features = false, features = ["raw-entry", "allocator-api2"] }
+hbbytecode = { workspace = true, features = ["disasm"] }
+hbvm = { workspace = true, features = ["nightly"] }
+log = "0.4.22"
+
+[dependencies.regalloc2]
+git = "https://github.com/jakubDoka/regalloc2"
+branch = "reuse-allocations"
+default-features = false
+
+[features]
+default = ["std", "regalloc2/trace-log"]
+std = []
+no_log = ["log/max_level_off"]

lang/command-help.txt

@@ -0,0 +1,4 @@
+--fmt            - format all imported source files
+--fmt-stdout     - dont write the formatted file but print it
+--dump-asm       - output assembly instead of raw code, (the assembly is more for debugging the compiler)
+--threads <1...> - number of extra threads compiler can use [default: 0]

lang/src/fmt.rs

@@ -0,0 +1,533 @@
+use {
+    crate::{
+        lexer::{self, Lexer, TokenKind},
+        parser::{self, CommentOr, CtorField, Expr, Poser, Radix, StructField},
+    },
+    core::fmt::{self},
+};
+
+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!()
+}
+
+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::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);
+        }
+
+        writeln!(f)?;
+        self.depth += 1;
+        let res = (|| {
+            for (i, stmt) in list.iter().enumerate() {
+                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(rest) = self.source.get(expr.posi() as usize..)
+                {
+                    if insert_needed_semicolon(rest) {
+                        f.write_str(";")?;
+                    }
+                    if preserve_newlines(&self.source[..expr.posi() as usize]) > 1 {
+                        f.write_str("\n")?;
+                    }
+                }
+                if add_sep {
+                    f.write_str("\n")?;
+                }
+            }
+            Ok(())
+        })();
+        self.depth -= 1;
+
+        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)
+        }
+    }
+
+    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::Ct { value, .. } => {
+                f.write_str("$: ")?;
+                self.fmt(value, f)
+            }
+            Expr::String { 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::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 ")?;
+                }
+
+                write!(f, "struct {{")?;
+                self.fmt_list_low(f, trailing_comma, "}", ",", fields, |s, field, f| {
+                    match field {
+                        CommentOr::Or(StructField { name, ty, .. }) => {
+                            f.write_str(name)?;
+                            f.write_str(": ")?;
+                            s.fmt(ty, f)?
+                        }
+                        CommentOr::Comment { literal, .. } => {
+                            f.write_str(literal)?;
+                            f.write_str("\n")?;
+                        }
+                    }
+                    Ok(field.or().is_some())
+                })
+            }
+            Expr::Ctor { ty, fields, trailing_comma, .. } => {
+                if let Some(ty) = ty {
+                    self.fmt_paren(ty, f, unary)?;
+                }
+                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::Tupl {
+                pos,
+                ty: Some(&Expr::Slice { pos: spos, size: Some(&Expr::Number { value, .. }), item }),
+                fields,
+                trailing_comma,
+            } if value as usize == fields.len() => self.fmt(
+                &Expr::Tupl {
+                    pos,
+                    ty: Some(&Expr::Slice { pos: spos, size: None, item }),
+                    fields,
+                    trailing_comma,
+                },
+                f,
+            ),
+            Expr::Tupl { ty, fields, trailing_comma, .. } => {
+                if let Some(ty) = ty {
+                    self.fmt_paren(ty, f, unary)?;
+                }
+                f.write_str(".(")?;
+                self.fmt_list(f, trailing_comma, ")", ",", fields, Self::fmt)
+            }
+            Expr::Slice { item, size, .. } => {
+                f.write_str("[")?;
+                self.fmt(item, f)?;
+                if let Some(size) = size {
+                    f.write_str("; ")?;
+                    self.fmt(size, f)?;
+                }
+                f.write_str("]")
+            }
+            Expr::Index { base, index } => {
+                self.fmt(base, f)?;
+                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::Loop { body, .. } => {
+                f.write_str("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::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::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 preserve_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 {
+                        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 preserve_newlines(source: &str) -> usize {
+    source[source.trim_end().len()..].bytes().filter(|&c| c == b'\n').count()
+}
+
+pub fn insert_needed_semicolon(source: &str) -> bool {
+    let kind = lexer::Lexer::new(source).eat().kind;
+    kind.precedence().is_some() || matches!(kind, TokenKind::Ctor | TokenKind::Tupl)
+}
+
+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(rest) = file.get(expr.pos() as usize..)
+        {
+            if insert_needed_semicolon(rest) {
+                write!(f, ";")?;
+            }
+
+            if preserve_newlines(&file[..expr.pos() as usize]) > 1 {
+                writeln!(f)?;
+            }
+        }
+
+        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::error!(
+        //    "{} / {} = {} | {} / {} = {}",
+        //    ast.mem.size(),
+        //    input.len(),
+        //    ast.mem.size() as f32 / input.len() as f32,
+        //    ast.mem.size(),
+        //    ast.file.len(),
+        //    ast.mem.size() as f32 / ast.file.len() as f32
+        //);
+        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,367 @@
+use {
+    crate::{
+        parser::{self, Ast, Ctx, FileKind},
+        son,
+    },
+    alloc::{string::String, vec::Vec},
+    core::{fmt::Write, num::NonZeroUsize, ops::Deref},
+    hashbrown::hash_map,
+    std::{
+        collections::VecDeque,
+        eprintln,
+        ffi::OsStr,
+        io::{self, Write as _},
+        path::{Path, PathBuf},
+        string::ToString,
+        sync::Mutex,
+    },
+};
+
+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) {}
+}
+
+#[derive(Default)]
+pub struct Options {
+    pub fmt: bool,
+    pub fmt_stdout: bool,
+    pub dump_asm: bool,
+    pub extra_threads: usize,
+}
+
+impl Options {
+    pub fn from_args(args: &[&str]) -> std::io::Result<Self> {
+        if args.contains(&"--help") || args.contains(&"-h") {
+            log::error!("Usage: hbc [OPTIONS...] <FILE>");
+            log::error!(include_str!("../command-help.txt"));
+            return Err(std::io::ErrorKind::Other.into());
+        }
+
+        Ok(Options {
+            fmt: args.contains(&"--fmt"),
+            fmt_stdout: args.contains(&"--fmt-stdout"),
+            dump_asm: args.contains(&"--dump-asm"),
+            extra_threads: args
+                .iter()
+                .position(|&a| a == "--threads")
+                .map(|i| {
+                    args[i + 1].parse::<NonZeroUsize>().map_err(|e| {
+                        std::io::Error::other(format!("--threads expects non zero integer: {e}"))
+                    })
+                })
+                .transpose()?
+                .map_or(1, NonZeroUsize::get)
+                - 1,
+        })
+    }
+}
+
+pub fn run_compiler(root_file: &str, options: Options, out: &mut Vec<u8>) -> std::io::Result<()> {
+    let parsed = parse_from_fs(options.extra_threads, root_file)?;
+
+    fn format_ast(ast: parser::Ast) -> std::io::Result<()> {
+        let mut output = String::new();
+        write!(output, "{ast}").unwrap();
+        if ast.file.deref().trim() != output.as_str().trim() {
+            std::fs::write(&*ast.path, output)?;
+        }
+        Ok(())
+    }
+
+    if options.fmt {
+        for parsed in parsed.ast {
+            format_ast(parsed)?;
+        }
+    } else if options.fmt_stdout {
+        let ast = parsed.ast.into_iter().next().unwrap();
+        write!(out, "{ast}").unwrap();
+    } else {
+        let mut ctx = crate::son::CodegenCtx::default();
+        *ctx.parser.errors.get_mut() = parsed.errors;
+        let mut codegen = son::Codegen::new(&parsed.ast, &mut ctx);
+
+        codegen.push_embeds(parsed.embeds);
+        codegen.generate(0);
+
+        if !codegen.errors.borrow().is_empty() {
+            log::error!("{}", codegen.errors.borrow());
+            return Err(std::io::Error::other("compilation faoled"));
+        }
+
+        if options.dump_asm {
+            codegen
+                .disasm(unsafe { std::mem::transmute::<&mut Vec<u8>, &mut String>(out) })
+                .map_err(|e| io::Error::other(e.to_string()))?;
+        } else {
+            codegen.assemble(out);
+        }
+    }
+
+    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,
+}
+
+pub fn parse_from_fs(extra_threads: usize, root: &str) -> io::Result<Loaded> {
+    fn 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 })
+    }
+
+    #[derive(Debug)]
+    struct CantLoadFile {
+        path: PathBuf,
+        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: {}", 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)
+        }
+    }
+
+    type Task = (u32, PathBuf);
+
+    let seen_modules = Mutex::new(crate::HashMap::<PathBuf, u32>::default());
+    let seen_embeds = Mutex::new(crate::HashMap::<PathBuf, u32>::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 as u32
+                        }
+                    }
+                };
+
+                if !physiscal_path.exists() {
+                    return Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("can't find file: {}", 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 as u32
+                        }
+                    }
+                };
+
+                let content = std::fs::read(&physiscal_path).map_err(|e| {
+                    io::Error::new(
+                        e.kind(),
+                        format!(
+                            "can't load embed file: {}: {e}",
+                            display_rel_path(&physiscal_path)
+                        ),
+                    )
+                })?;
+                let mut embeds = embeds.lock().unwrap();
+                if id as usize >= embeds.len() {
+                    embeds.resize(id as usize + 1, Default::default());
+                }
+                embeds[id as usize] = 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: {}", 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 as usize + 1);
+            ast.resize_with(len, || Err(io::ErrorKind::InvalidData.into()));
+            ast[indx as usize] = 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,
+    })
+}
+
+pub fn display_rel_path(path: &(impl AsRef<OsStr> + ?Sized)) -> std::path::Display {
+    static CWD: std::sync::LazyLock<PathBuf> =
+        std::sync::LazyLock::new(|| std::env::current_dir().unwrap_or_default());
+    std::path::Path::new(path).strip_prefix(&*CWD).unwrap_or(std::path::Path::new(path)).display()
+}

lang/src/fuzz.rs

@@ -0,0 +1,139 @@
+use {
+    crate::{
+        lexer::TokenKind,
+        parser,
+        son::{Codegen, CodegenCtx},
+    },
+    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 cdg = Codegen::new(core::slice::from_ref(&parsed), &mut ctx);
+        cdg.generate(0);
+    }
+}

lang/src/fuzz_main.rs

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

lang/src/lexer.rs

@@ -0,0 +1,552 @@
+const fn ascii_mask(chars: &[u8]) -> u128 {
+    let mut eq = 0;
+    let mut i = 0;
+    while i < chars.len() {
+        let b = chars[i];
+        eq |= 1 << b;
+        i += 1;
+    }
+    eq
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Token {
+    pub kind: TokenKind,
+    pub start: u32,
+    pub end: u32,
+}
+
+impl Token {
+    pub fn range(&self) -> core::ops::Range<usize> {
+        self.start as usize..self.end as usize
+    }
+}
+
+macro_rules! gen_token_kind {
+    ($(
+        #[$atts:meta])*
+        $vis:vis enum $name:ident {
+            #[patterns] $(
+                $pattern:ident,
+            )*
+            #[keywords] $(
+                $keyword:ident = $keyword_lit:literal,
+            )*
+            #[punkt] $(
+                $punkt:ident = $punkt_lit:literal,
+            )*
+            #[ops] $(
+                #[$prec:ident] $(
+                    $op:ident = $op_lit:literal $(=> $assign:ident)?,
+                )*
+            )*
+        }
+    ) => {
+        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::$punkt   => stringify!($punkt_lit),   )*
+                    $($( Self::$op    => $op_lit,
+                      $(Self::$assign => concat!($op_lit, "="),)?)*)*
+                    _ => unsafe { core::str::from_utf8_unchecked(core::slice::from_ref(&sf)) },
+                }
+            }
+
+            #[inline(always)]
+            pub fn precedence(&self) -> Option<u8> {
+                Some(match self {
+                    $($(Self::$op => ${ignore($prec)} ${index(1)},
+                      $(Self::$assign => 0,)?)*)*
+                    _ => return None,
+                } + 1)
+            }
+
+            fn from_ident(ident: &[u8]) -> Self {
+                match ident {
+                    $($keyword_lit => Self::$keyword,)*
+                    _ => Self::Ident,
+                }
+            }
+        }
+    };
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, Hash, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum TokenKind {
+    Not = b'!',
+    DQuote = b'"',
+    Pound = b'#',
+    CtIdent = b'$',
+    Mod = b'%',
+    Band = b'&',
+    Quote = b'\'',
+    LParen = b'(',
+    RParen = b')',
+    Mul = b'*',
+    Add = b'+',
+    Comma = b',',
+    Sub = b'-',
+    Dot = b'.',
+    Div = b'/',
+    // Unused = 2-6
+    Shl = b'<' - 5,
+    // Unused = 8
+    Shr = b'>' - 5,
+    Colon = b':',
+    Semi = b';',
+    Lt = b'<',
+    Assign = b'=',
+    Gt = b'>',
+    Que = b'?',
+    Directive = b'@',
+
+    Comment,
+
+    Ident,
+    Number,
+    Float,
+    Eof,
+
+    Ct,
+
+    Return,
+    If,
+    Else,
+    Loop,
+    Break,
+    Continue,
+    Fn,
+    Struct,
+    Packed,
+    True,
+    False,
+    Null,
+    Idk,
+
+    Ctor,
+    Tupl,
+
+    Or,
+    And,
+
+    // Unused = R-Z
+    LBrack = b'[',
+    BSlash = b'\\',
+    RBrack = b']',
+    Xor = b'^',
+    Tick = b'`',
+    // Unused = a-z
+    LBrace = b'{',
+    Bor = b'|',
+    RBrace = b'}',
+    Tilde = b'~',
+
+    Decl = b':' + 128,
+    Eq = b'=' + 128,
+    Ne = b'!' + 128,
+    Le = b'<' + 128,
+    Ge = b'>' + 128,
+
+    BorAss = b'|' + 128,
+    AddAss = b'+' + 128,
+    SubAss = b'-' + 128,
+    MulAss = b'*' + 128,
+    DivAss = b'/' + 128,
+    ModAss = b'%' + 128,
+    XorAss = b'^' + 128,
+    BandAss = b'&' + 128,
+    ShrAss = b'>' - 5 + 128,
+    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 {
+    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 { core::mem::transmute::<u8, Self>(id) })
+    }
+
+    pub fn is_comutative(self) -> bool {
+        use TokenKind as S;
+        matches!(self, S::Eq | S::Ne | S::Bor | S::Xor | S::Band | S::Add | S::Mul)
+    }
+
+    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}"),
+        }
+    }
+
+    pub fn is_homogenous(&self) -> bool {
+        self.precedence() != Self::Eq.precedence()
+            && self.precedence() != Self::Gt.precedence()
+            && self.precedence() != Self::Eof.precedence()
+    }
+
+    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::Float if float => value,
+            Self::Float => (value as f64).to_bits() as _,
+            Self::Number => {
+                debug_assert!(float);
+                f64::from_bits(value as _).to_bits() as _
+            }
+            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! {
+    pub enum TokenKind {
+        #[patterns]
+        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",
+        Packed    = b"packed",
+        True      = b"true",
+        False     = b"false",
+        Null      = b"null",
+        Idk       = b"idk",
+        #[punkt]
+        Ctor   = ".{",
+        Tupl   = ".(",
+        // #define OP: each `#[prec]` delimeters a level of precedence from lowest to highest
+        #[ops]
+        #[prec]
+        // this also includess all `<op>=` tokens
+        Decl   = ":=",
+        Assign = "=",
+        #[prec]
+        Or = "||",
+        #[prec]
+        And = "&&",
+        #[prec]
+        Bor = "|" => BorAss,
+        #[prec]
+        Xor = "^" => XorAss,
+        #[prec]
+        Band = "&" => BandAss,
+        #[prec]
+        Eq = "==",
+        Ne = "!=",
+        #[prec]
+        Le = "<=",
+        Ge = ">=",
+        Lt = "<",
+        Gt = ">",
+        #[prec]
+        Shl = "<<" => ShlAss,
+        Shr = ">>" => ShrAss,
+        #[prec]
+        Add = "+" => AddAss,
+        Sub = "-" => SubAss,
+        #[prec]
+        Mul = "*" => MulAss,
+        Div = "/" => DivAss,
+        Mod = "%" => ModAss,
+    }
+}
+
+pub struct Lexer<'a> {
+    pos: u32,
+    source: &'a [u8],
+}
+
+impl<'a> Lexer<'a> {
+    pub fn new(input: &'a str) -> Self {
+        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, source: input.as_bytes() }
+    }
+
+    pub fn source(&self) -> &'a str {
+        unsafe { core::str::from_utf8_unchecked(self.source) }
+    }
+
+    pub fn slice(&self, tok: core::ops::Range<usize>) -> &'a str {
+        unsafe { core::str::from_utf8_unchecked(&self.source[tok]) }
+    }
+
+    fn peek(&self) -> Option<u8> {
+        if core::intrinsics::unlikely(self.pos >= self.source.len() as u32) {
+            None
+        } else {
+            Some(unsafe { *self.source.get_unchecked(self.pos as usize) })
+        }
+    }
+
+    fn advance(&mut self) -> Option<u8> {
+        let c = self.peek()?;
+        self.pos += 1;
+        Some(c)
+    }
+
+    pub fn last(&mut self) -> Token {
+        let mut token = self.eat();
+        loop {
+            let next = self.eat();
+            if next.kind == TokenKind::Eof {
+                break;
+            }
+            token = next;
+        }
+        token
+    }
+
+    pub fn eat(&mut self) -> Token {
+        use TokenKind as T;
+        loop {
+            let mut start = self.pos;
+
+            let Some(c) = self.advance() else {
+                return Token { kind: T::Eof, start, end: self.pos };
+            };
+
+            let advance_ident = |s: &mut Self| {
+                while let Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_' | 127..) = s.peek() {
+                    s.advance();
+                }
+            };
+
+            let identity = |s: u8| unsafe { core::mem::transmute::<u8, T>(s) };
+
+            let kind = match c {
+                ..=b' ' => continue,
+                b'0' if self.advance_if(b'x') => {
+                    while let Some(b'0'..=b'9' | b'A'..=b'F' | b'a'..=b'f') = self.peek() {
+                        self.advance();
+                    }
+                    T::Number
+                }
+                b'0' if self.advance_if(b'b') => {
+                    while let Some(b'0' | b'1') = self.peek() {
+                        self.advance();
+                    }
+                    T::Number
+                }
+                b'0' if self.advance_if(b'o') => {
+                    while let Some(b'0'..=b'7') = self.peek() {
+                        self.advance();
+                    }
+                    T::Number
+                }
+                b'0'..=b'9' => {
+                    while let Some(b'0'..=b'9') = self.peek() {
+                        self.advance();
+                    }
+
+                    if self.advance_if(b'.') {
+                        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.source[start as usize..self.pos as usize];
+                    T::from_ident(ident)
+                }
+                b'"' | b'\'' => loop {
+                    match self.advance() {
+                        Some(b'\\') => _ = self.advance(),
+                        Some(nc) if nc == c => break identity(c),
+                        Some(_) => {}
+                        None => break T::Eof,
+                    }
+                },
+                b'/' if self.advance_if(b'/') => {
+                    while let Some(l) = self.peek()
+                        && l != b'\n'
+                    {
+                        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;
+                    while let Some(l) = self.advance() {
+                        match l {
+                            b'/' if self.advance_if(b'*') => depth += 1,
+                            b'*' if self.advance_if(b'/') => match depth {
+                                1 => break,
+                                _ => depth -= 1,
+                            },
+                            _ => {}
+                        }
+                    }
+                    T::Comment
+                }
+                b'.' if self.advance_if(b'{') => T::Ctor,
+                b'.' if self.advance_if(b'(') => T::Tupl,
+                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'$' => {
+                    start += 1;
+                    advance_ident(self);
+                    identity(c)
+                }
+                b'<' | b'>' if self.advance_if(c) => {
+                    identity(c - 5 + 128 * self.advance_if(b'=') as u8)
+                }
+                b':' | b'=' | b'!' | b'<' | b'>' | b'|' | b'+' | b'-' | b'*' | b'/' | b'%'
+                | b'^' | b'&'
+                    if self.advance_if(b'=') =>
+                {
+                    identity(c + 128)
+                }
+                _ => identity(c),
+            };
+
+            return Token { kind, start, end: self.pos };
+        }
+    }
+
+    fn advance_if(&mut self, arg: u8) -> bool {
+        if self.peek() == Some(arg) {
+            self.advance();
+            true
+        } else {
+            false
+        }
+    }
+}
+
+pub fn line_col(bytes: &[u8], pos: u32) -> (usize, usize) {
+    bytes[..pos as usize]
+        .split(|&b| b == b'\n')
+        .map(<[u8]>::len)
+        .enumerate()
+        .last()
+        .map(|(line, col)| (line + 1, col + 1))
+        .unwrap_or((1, 1))
+}

lang/src/main.rs

@@ -0,0 +1,17 @@
+#[cfg(feature = "std")]
+fn main() -> std::io::Result<()> {
+    use std::io::Write;
+
+    log::set_logger(&hblang::Logger).unwrap();
+    log::set_max_level(log::LevelFilter::Info);
+
+    let args = std::env::args().collect::<Vec<_>>();
+    let args = args.iter().map(String::as_str).collect::<Vec<_>>();
+
+    let opts = hblang::Options::from_args(&args)?;
+    let file = args.iter().filter(|a| !a.starts_with('-')).nth(1).copied().unwrap_or("main.hb");
+
+    let mut out = Vec::new();
+    hblang::run_compiler(file, opts, &mut out)?;
+    std::io::stdout().write_all(&out)
+}

lang/src/regalloc.rs

@@ -0,0 +1,150 @@
+use {crate::reg::Reg, alloc::vec::Vec, core::ops::Range};
+
+type Nid = u16;
+
+pub trait Ctx {
+    fn uses_of(&self, nid: Nid) -> impl Iterator<Item = Nid>;
+    fn params_of(&self, nid: Nid) -> impl Iterator<Item = Nid>;
+    fn args_of(&self, nid: Nid) -> impl Iterator<Item = Nid>;
+    fn dom_of(&self, nid: Nid) -> Nid;
+}
+
+pub struct Env<'a, C: Ctx> {
+    ctx: &'a C,
+    func: &'a Func,
+    res: &'a mut Res,
+}
+
+impl<'a, C: Ctx> Env<'a, C> {
+    pub fn new(ctx: &'a C, func: &'a Func, res: &'a mut Res) -> Self {
+        Self { ctx, func, res }
+    }
+
+    pub fn run(&mut self) {
+        self.res.reg_to_node.clear();
+        self.res.reg_to_node.resize(self.func.instrs.len(), 0);
+
+        let mut bundle = Bundle::new(self.func.instrs.len());
+        for &inst in &self.func.instrs {
+            for uinst in self.ctx.uses_of(inst) {
+                let mut cursor = self.ctx.dom_of(uinst);
+                while cursor != self.ctx.dom_of(inst) {
+                    let mut range = self.func.blocks
+                        [self.func.id_to_block[cursor as usize] as usize]
+                        .range
+                        .clone();
+                    range.start = range.start.max(inst as usize);
+                    range.end = range.end.min(uinst as usize);
+                    bundle.add(range);
+                    cursor = self.ctx.dom_of(cursor);
+                }
+            }
+
+            match self.res.bundles.iter_mut().enumerate().find(|(_, b)| !b.overlaps(&bundle)) {
+                Some((i, other)) => {
+                    other.merge(&bundle);
+                    bundle.clear();
+                    self.res.reg_to_node[inst as usize] = i as Reg;
+                }
+                None => {
+                    self.res.reg_to_node[inst as usize] = self.res.bundles.len() as Reg;
+                    self.res.bundles.push(bundle);
+                    bundle = Bundle::new(self.func.instrs.len());
+                }
+            }
+        }
+    }
+}
+
+pub struct Res {
+    bundles: Vec<Bundle>,
+    pub reg_to_node: Vec<Reg>,
+}
+
+pub struct Bundle {
+    //unit_range: Range<usize>,
+    //set: BitSet,
+    taken: Vec<bool>,
+}
+
+impl Bundle {
+    fn new(size: usize) -> Self {
+        Self { taken: vec![false; size] }
+    }
+
+    fn add(&mut self, range: Range<usize>) {
+        self.taken[range].fill(true);
+    }
+
+    fn overlaps(&self, other: &Self) -> bool {
+        self.taken.iter().zip(other.taken.iter()).any(|(a, b)| a & b)
+    }
+
+    fn merge(&mut self, other: &Self) {
+        debug_assert!(!self.overlaps(other));
+        self.taken.iter_mut().zip(other.taken.iter()).for_each(|(a, b)| *a = *b);
+    }
+
+    fn clear(&mut self) {
+        self.taken.fill(false);
+    }
+
+    //fn overlaps(&self, other: &Self) -> bool {
+    //    if self.unit_range.start >= other.unit_range.end
+    //        || self.unit_range.end <= other.unit_range.start
+    //    {
+    //        return false;
+    //    }
+
+    //    let [mut a, mut b] = [self, other];
+    //    if a.unit_range.start > b.unit_range.start {
+    //        mem::swap(&mut a, &mut b);
+    //    }
+    //    let [mut tmp_a, mut tmp_b] = [0; 2];
+    //    let [units_a, units_b] = [a.set.units(&mut tmp_a), b.set.units(&mut tmp_b)];
+    //    let len = a.unit_range.len().min(b.unit_range.len());
+    //    let [units_a, units_b] =
+    //        [&units_a[b.unit_range.start - a.unit_range.start..][..len], &units_b[..len]];
+    //    units_a.iter().zip(units_b).any(|(&a, &b)| a & b != 0)
+    //}
+
+    //fn merge(mut self, mut other: Self) -> Self {
+    //    debug_assert!(!self.overlaps(&other));
+
+    //    if self.unit_range.start > other.unit_range.start {
+    //        mem::swap(&mut self, &mut other);
+    //    }
+
+    //    let final_range = self.unit_range.start..self.unit_range.end.max(other.unit_range.end);
+
+    //    self.set.reserve(final_range.len());
+
+    //    let mut tmp = 0;
+    //    let other_units = other.set.units(&mut tmp);
+
+    //    match self.set.units_mut() {
+    //        Ok(units) => {
+    //            units[other.unit_range.start - self.unit_range.start..]
+    //                .iter_mut()
+    //                .zip(other_units)
+    //                .for_each(|(a, b)| *a |= b);
+    //        }
+    //        Err(view) => view.add_mask(tmp),
+    //    }
+
+    //    self
+    //}
+}
+
+pub struct Func {
+    pub blocks: Vec<Block>,
+    pub instrs: Vec<Nid>,
+    pub id_to_instr: Vec<Nid>,
+    pub id_to_block: Vec<Nid>,
+}
+
+pub struct Block {
+    pub range: Range<usize>,
+    pub start_id: Nid,
+    pub eld_id: Nid,
+}

lang/src/utils.rs

@@ -0,0 +1,528 @@
+#![expect(dead_code)]
+use {
+    alloc::alloc,
+    core::{
+        alloc::Layout,
+        fmt::Debug,
+        hint::unreachable_unchecked,
+        mem::MaybeUninit,
+        ops::{Deref, DerefMut, Not},
+        ptr::Unique,
+    },
+};
+
+type Nid = u16;
+
+pub union BitSet {
+    inline: usize,
+    alloced: Unique<AllocedBitSet>,
+}
+
+impl Debug for BitSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
+impl Clone for BitSet {
+    fn clone(&self) -> Self {
+        if self.is_inline() {
+            Self { inline: unsafe { self.inline } }
+        } else {
+            let (data, _) = self.data_and_len();
+            let (layout, _) = Self::layout(data.len());
+            unsafe {
+                let ptr = alloc::alloc(layout);
+                ptr.copy_from_nonoverlapping(self.alloced.as_ptr() as _, layout.size());
+                Self { alloced: Unique::new_unchecked(ptr as _) }
+            }
+        }
+    }
+}
+
+impl Drop for BitSet {
+    fn drop(&mut self) {
+        if !self.is_inline() {
+            unsafe {
+                let cap = self.alloced.as_ref().cap;
+                alloc::dealloc(self.alloced.as_ptr() as _, Self::layout(cap).0);
+            }
+        }
+    }
+}
+
+impl Default for BitSet {
+    fn default() -> Self {
+        Self { inline: Self::FLAG }
+    }
+}
+
+impl BitSet {
+    const FLAG: usize = 1 << (Self::UNIT - 1);
+    const INLINE_ELEMS: usize = Self::UNIT - 1;
+    const UNIT: usize = core::mem::size_of::<usize>() * 8;
+
+    fn is_inline(&self) -> bool {
+        unsafe { self.inline & Self::FLAG != 0 }
+    }
+
+    fn data_and_len(&self) -> (&[usize], usize) {
+        unsafe {
+            if self.is_inline() {
+                (core::slice::from_ref(&self.inline), Self::INLINE_ELEMS)
+            } else {
+                let small_vec = self.alloced.as_ref();
+                (
+                    core::slice::from_raw_parts(
+                        &small_vec.data as *const _ as *const usize,
+                        small_vec.cap,
+                    ),
+                    small_vec.cap * core::mem::size_of::<usize>() * 8,
+                )
+            }
+        }
+    }
+
+    fn data_mut_and_len(&mut self) -> (&mut [usize], usize) {
+        unsafe {
+            if self.is_inline() {
+                (core::slice::from_mut(&mut self.inline), INLINE_ELEMS)
+            } else {
+                let small_vec = self.alloced.as_mut();
+                (
+                    core::slice::from_raw_parts_mut(
+                        &mut small_vec.data as *mut _ as *mut usize,
+                        small_vec.cap,
+                    ),
+                    small_vec.cap * Self::UNIT,
+                )
+            }
+        }
+    }
+
+    fn indexes(index: usize) -> (usize, usize) {
+        (index / Self::UNIT, index % Self::UNIT)
+    }
+
+    pub fn get(&self, index: Nid) -> bool {
+        let index = index as usize;
+        let (data, len) = self.data_and_len();
+        if index >= len {
+            return false;
+        }
+        let (elem, bit) = Self::indexes(index);
+        (unsafe { *data.get_unchecked(elem) }) & (1 << bit) != 0
+    }
+
+    pub fn set(&mut self, index: Nid) -> bool {
+        let index = index as usize;
+        let (mut data, len) = self.data_mut_and_len();
+        if core::intrinsics::unlikely(index >= len) {
+            self.grow(index.next_power_of_two().max(4 * Self::UNIT));
+            (data, _) = self.data_mut_and_len();
+        }
+
+        let (elem, bit) = Self::indexes(index);
+        let elem = unsafe { data.get_unchecked_mut(elem) };
+        let prev = *elem;
+        *elem |= 1 << bit;
+        *elem != prev
+    }
+
+    fn grow(&mut self, size: usize) {
+        debug_assert!(size.is_power_of_two());
+        let slot_count = size / Self::UNIT;
+        let (layout, off) = Self::layout(slot_count);
+        let (ptr, prev_len) = unsafe {
+            if self.is_inline() {
+                let ptr = alloc::alloc(layout);
+                *ptr.add(off).cast::<usize>() = self.inline & !Self::FLAG;
+                (ptr, 1)
+            } else {
+                let prev_len = self.alloced.as_ref().cap;
+                let (prev_layout, _) = Self::layout(prev_len);
+                (alloc::realloc(self.alloced.as_ptr() as _, prev_layout, layout.size()), prev_len)
+            }
+        };
+        unsafe {
+            MaybeUninit::fill(
+                core::slice::from_raw_parts_mut(
+                    ptr.add(off).cast::<MaybeUninit<usize>>().add(prev_len),
+                    slot_count - prev_len,
+                ),
+                0,
+            );
+            *ptr.cast::<usize>() = slot_count;
+            core::ptr::write(self, Self { alloced: Unique::new_unchecked(ptr as _) });
+        }
+    }
+
+    fn layout(slot_count: usize) -> (core::alloc::Layout, usize) {
+        unsafe {
+            core::alloc::Layout::new::<AllocedBitSet>()
+                .extend(Layout::array::<usize>(slot_count).unwrap_unchecked())
+                .unwrap_unchecked()
+        }
+    }
+
+    pub fn iter(&self) -> BitSetIter {
+        if self.is_inline() {
+            BitSetIter { index: 0, current: unsafe { self.inline & !Self::FLAG }, remining: &[] }
+        } else {
+            let &[current, ref remining @ ..] = self.data_and_len().0 else {
+                unsafe { unreachable_unchecked() }
+            };
+            BitSetIter { index: 0, current, remining }
+        }
+    }
+
+    pub fn clear(&mut self, len: usize) {
+        self.reserve(len);
+        if self.is_inline() {
+            unsafe { self.inline &= Self::FLAG };
+        } else {
+            self.data_mut_and_len().0.fill(0);
+        }
+    }
+
+    pub fn units<'a>(&'a self, slot: &'a mut usize) -> &'a [usize] {
+        if self.is_inline() {
+            *slot = unsafe { self.inline } & !Self::FLAG;
+            core::slice::from_ref(slot)
+        } else {
+            self.data_and_len().0
+        }
+    }
+
+    pub fn reserve(&mut self, len: usize) {
+        if len > self.data_and_len().1 {
+            self.grow(len.next_power_of_two().max(4 * Self::UNIT));
+        }
+    }
+
+    pub fn units_mut(&mut self) -> Result<&mut [usize], &mut InlineBitSetView> {
+        if self.is_inline() {
+            Err(unsafe {
+                core::mem::transmute::<&mut usize, &mut InlineBitSetView>(&mut self.inline)
+            })
+        } else {
+            Ok(self.data_mut_and_len().0)
+        }
+    }
+}
+
+pub struct InlineBitSetView(usize);
+
+impl InlineBitSetView {
+    pub(crate) fn add_mask(&mut self, tmp: usize) {
+        debug_assert!(tmp & BitSet::FLAG == 0);
+        self.0 |= tmp;
+    }
+}
+
+pub struct BitSetIter<'a> {
+    index: usize,
+    current: usize,
+    remining: &'a [usize],
+}
+
+impl Iterator for BitSetIter<'_> {
+    type Item = usize;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.current == 0 {
+            self.current = *self.remining.take_first()?;
+            self.index += 1;
+        }
+
+        let sub_idx = self.current.trailing_zeros() as usize;
+        self.current &= self.current - 1;
+        Some(self.index * BitSet::UNIT + sub_idx)
+    }
+}
+
+struct AllocedBitSet {
+    cap: usize,
+    data: [usize; 0],
+}
+
+#[cfg(test)]
+#[test]
+fn test_small_bit_set() {
+    use std::vec::Vec;
+
+    let mut sv = BitSet::default();
+
+    sv.set(10);
+    debug_assert!(sv.get(10));
+    sv.set(100);
+    debug_assert!(sv.get(100));
+    sv.set(10000);
+    debug_assert!(sv.get(10000));
+    debug_assert_eq!(sv.iter().collect::<Vec<_>>(), &[10, 100, 10000]);
+    sv.clear(10000);
+    debug_assert_eq!(sv.iter().collect::<Vec<_>>(), &[]);
+}
+
+pub union Vc {
+    inline: InlineVc,
+    alloced: AllocedVc,
+}
+
+impl Default for Vc {
+    fn default() -> Self {
+        Vc { inline: InlineVc { elems: MaybeUninit::uninit(), cap: Default::default() } }
+    }
+}
+
+impl Debug for Vc {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.as_slice().fmt(f)
+    }
+}
+
+impl FromIterator<Nid> for Vc {
+    fn from_iter<T: IntoIterator<Item = Nid>>(iter: T) -> Self {
+        let mut slf = Self::default();
+        for i in iter {
+            slf.push(i);
+        }
+        slf
+    }
+}
+
+const INLINE_ELEMS: usize = VC_SIZE / 2 - 1;
+const VC_SIZE: usize = 16;
+
+impl Vc {
+    fn is_inline(&self) -> bool {
+        unsafe { self.inline.cap <= INLINE_ELEMS as Nid }
+    }
+
+    fn layout(&self) -> Option<core::alloc::Layout> {
+        unsafe {
+            self.is_inline().not().then(|| {
+                core::alloc::Layout::array::<Nid>(self.alloced.cap as _).unwrap_unchecked()
+            })
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        unsafe {
+            if self.is_inline() {
+                self.inline.cap as _
+            } else {
+                self.alloced.len as _
+            }
+        }
+    }
+
+    fn len_mut(&mut self) -> &mut Nid {
+        unsafe {
+            if self.is_inline() {
+                &mut self.inline.cap
+            } else {
+                &mut self.alloced.len
+            }
+        }
+    }
+
+    fn as_ptr(&self) -> *const Nid {
+        unsafe {
+            match self.is_inline() {
+                true => self.inline.elems.as_ptr().cast(),
+                false => self.alloced.base.as_ptr(),
+            }
+        }
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut Nid {
+        unsafe {
+            match self.is_inline() {
+                true => self.inline.elems.as_mut_ptr().cast(),
+                false => self.alloced.base.as_ptr(),
+            }
+        }
+    }
+
+    pub fn as_slice(&self) -> &[Nid] {
+        unsafe { core::slice::from_raw_parts(self.as_ptr(), self.len()) }
+    }
+
+    fn as_slice_mut(&mut self) -> &mut [Nid] {
+        unsafe { core::slice::from_raw_parts_mut(self.as_mut_ptr(), self.len()) }
+    }
+
+    pub fn push(&mut self, value: Nid) {
+        if let Some(layout) = self.layout()
+            && unsafe { self.alloced.len == self.alloced.cap }
+        {
+            unsafe {
+                self.alloced.cap *= 2;
+                self.alloced.base = Unique::new_unchecked(
+                    alloc::realloc(
+                        self.alloced.base.as_ptr().cast(),
+                        layout,
+                        self.alloced.cap as usize * core::mem::size_of::<Nid>(),
+                    )
+                    .cast(),
+                );
+            }
+        } else if self.len() == INLINE_ELEMS {
+            unsafe {
+                let mut allcd =
+                    Self::alloc((self.inline.cap + 1).next_power_of_two() as _, self.len());
+                core::ptr::copy_nonoverlapping(self.as_ptr(), allcd.as_mut_ptr(), self.len());
+                *self = allcd;
+            }
+        }
+
+        unsafe {
+            *self.len_mut() += 1;
+            self.as_mut_ptr().add(self.len() - 1).write(value);
+        }
+    }
+
+    unsafe fn alloc(cap: usize, len: usize) -> Self {
+        debug_assert!(cap > INLINE_ELEMS);
+        let layout = unsafe { core::alloc::Layout::array::<Nid>(cap).unwrap_unchecked() };
+        let alloc = unsafe { alloc::alloc(layout) };
+        unsafe {
+            Vc {
+                alloced: AllocedVc {
+                    base: Unique::new_unchecked(alloc.cast()),
+                    len: len as _,
+                    cap: cap as _,
+                },
+            }
+        }
+    }
+
+    pub fn swap_remove(&mut self, index: usize) {
+        let len = self.len() - 1;
+        self.as_slice_mut().swap(index, len);
+        *self.len_mut() -= 1;
+    }
+
+    pub fn remove(&mut self, index: usize) {
+        self.as_slice_mut().copy_within(index + 1.., index);
+        *self.len_mut() -= 1;
+    }
+}
+
+impl Drop for Vc {
+    fn drop(&mut self) {
+        if let Some(layout) = self.layout() {
+            unsafe {
+                alloc::dealloc(self.alloced.base.as_ptr().cast(), layout);
+            }
+        }
+    }
+}
+
+impl Clone for Vc {
+    fn clone(&self) -> Self {
+        self.as_slice().into()
+    }
+}
+
+impl IntoIterator for Vc {
+    type IntoIter = VcIntoIter;
+    type Item = Nid;
+
+    fn into_iter(self) -> Self::IntoIter {
+        VcIntoIter { start: 0, end: self.len(), vc: self }
+    }
+}
+
+pub struct VcIntoIter {
+    start: usize,
+    end: usize,
+    vc: Vc,
+}
+
+impl Iterator for VcIntoIter {
+    type Item = Nid;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.start == self.end {
+            return None;
+        }
+
+        let ret = unsafe { core::ptr::read(self.vc.as_slice().get_unchecked(self.start)) };
+        self.start += 1;
+        Some(ret)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.end - self.start;
+        (len, Some(len))
+    }
+}
+
+impl DoubleEndedIterator for VcIntoIter {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.start == self.end {
+            return None;
+        }
+
+        self.end -= 1;
+        Some(unsafe { core::ptr::read(self.vc.as_slice().get_unchecked(self.end)) })
+    }
+}
+
+impl ExactSizeIterator for VcIntoIter {}
+
+impl<const SIZE: usize> From<[Nid; SIZE]> for Vc {
+    fn from(value: [Nid; SIZE]) -> Self {
+        value.as_slice().into()
+    }
+}
+
+impl<'a> From<&'a [Nid]> for Vc {
+    fn from(value: &'a [Nid]) -> Self {
+        if value.len() <= INLINE_ELEMS {
+            let mut dflt = Self::default();
+            unsafe {
+                core::ptr::copy_nonoverlapping(value.as_ptr(), dflt.as_mut_ptr(), value.len())
+            };
+            dflt.inline.cap = value.len() as _;
+            dflt
+        } else {
+            let mut allcd = unsafe { Self::alloc(value.len(), value.len()) };
+            unsafe {
+                core::ptr::copy_nonoverlapping(value.as_ptr(), allcd.as_mut_ptr(), value.len())
+            };
+            allcd
+        }
+    }
+}
+
+impl Deref for Vc {
+    type Target = [Nid];
+
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+
+impl DerefMut for Vc {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.as_slice_mut()
+    }
+}
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+struct InlineVc {
+    cap: Nid,
+    elems: MaybeUninit<[Nid; INLINE_ELEMS]>,
+}
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+struct AllocedVc {
+    cap: Nid,
+    len: Nid,
+    base: Unique<Nid>,
+}

lang/tests/son_tests_aliasing_overoptimization.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+code size: 29
+ret: 0
+status: Ok(())

lang/tests/son_tests_arithmetic.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+code size: 29
+ret: 0
+status: Ok(())

lang/tests/son_tests_arrays.txt

@@ -0,0 +1,27 @@
+main:
+    ADDI64 r254, r254, -40d
+    ST r31, r254, 24a, 16h
+    LI64 r32, 1d
+    ADDI64 r2, r254, 0d
+    ST r32, r254, 0a, 8h
+    LI64 r5, 2d
+    ST r5, r254, 8a, 8h
+    LI64 r8, 4d
+    ST r8, r254, 16a, 8h
+    JAL r31, r0, :pass
+    ADD64 r1, r1, r32
+    LD r31, r254, 24a, 16h
+    ADDI64 r254, r254, 40d
+    JALA r0, r31, 0a
+pass:
+    LD r4, r2, 8a, 8h
+    MULI64 r7, r4, 8d
+    LD r5, r2, 0a, 8h
+    ADD64 r10, r7, r2
+    ADD64 r9, r4, r5
+    LD r1, r10, 0a, 8h
+    ADD64 r1, r1, r9
+    JALA r0, r31, 0a
+code size: 231
+ret: 8
+status: Ok(())

lang/tests/son_tests_big_array_crash.txt

@@ -0,0 +1,7 @@
+main:
+    LRA r1, r0, :SIN_TABLE
+    LD r1, r1, 80a, 8h
+    JALA r0, r31, 0a
+code size: 767
+ret: 1736
+status: Ok(())

lang/tests/son_tests_branch_assignments.txt

@@ -0,0 +1,13 @@
+main:
+    LI64 r1, 1d
+    JNE r2, r1, :0
+    JMP :1
+ 0: LI64 r7, 0d
+    JNE r2, r7, :2
+    LI64 r1, 2d
+    JMP :1
+ 2: LI64 r1, 3d
+ 1: JALA r0, r31, 0a
+code size: 79
+ret: 2
+status: Ok(())

lang/tests/son_tests_c_strings.txt

@@ -0,0 +1,28 @@
+main:
+    ADDI64 r254, r254, -16d
+    ST r31, r254, 0a, 16h
+    LRA r2, r0, :"abඞ\n\r\t56789\0"
+    JAL r31, r0, :str_len
+    CP r32, r1
+    LRA r2, r0, :"fff\0"
+    JAL r31, r0, :str_len
+    CP r10, r32
+    ADD64 r1, r1, r10
+    LD r31, r254, 0a, 16h
+    ADDI64 r254, r254, 16d
+    JALA r0, r31, 0a
+str_len:
+    LI8 r6, 0b
+    LI64 r1, 0d
+ 2: LD r8, r2, 0a, 1h
+    ANDI r8, r8, 255d
+    ANDI r6, r6, 255d
+    JNE r8, r6, :0
+    JMP :1
+ 0: ADDI64 r2, r2, 1d
+    ADDI64 r1, r1, 1d
+    JMP :2
+ 1: JALA r0, r31, 0a
+code size: 219
+ret: 16
+status: Ok(())

lang/tests/son_tests_comments.txt

@@ -0,0 +1,13 @@
+foo:
+    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: 95
+ret: 0
+status: Ok(())

lang/tests/son_tests_comptime_function_from_another_file.txt

@@ -0,0 +1,7 @@
+main:
+    LRA r1, r0, :a
+    LD r1, r1, 0a, 8h
+    JALA r0, r31, 0a
+code size: 47
+ret: 50
+status: Ok(())

lang/tests/son_tests_comptime_min_reg_leak.txt

@@ -0,0 +1,7 @@
+main:
+    LRA r1, r0, :a
+    LD r1, r1, 0a, 8h
+    JALA r0, r31, 0a
+code size: 47
+ret: 50
+status: Ok(())

lang/tests/son_tests_conditional_stores.txt

@@ -0,0 +1,20 @@
+cond:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+main:
+    ADDI64 r254, r254, -8d
+    ST r31, r254, 0a, 8h
+    JAL r31, r0, :cond
+    LI64 r5, 0d
+    CP r7, r5
+    JNE r1, r7, :0
+    CP r5, r7
+    CP r1, r5
+    JMP :1
+ 0: LI64 r1, 2d
+ 1: LD r31, r254, 0a, 8h
+    ADDI64 r254, r254, 8d
+    JALA r0, r31, 0a
+code size: 134
+ret: 0
+status: Ok(())

lang/tests/son_tests_const_folding_with_arg.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+code size: 29
+ret: 0
+status: Ok(())

lang/tests/son_tests_dead_code_in_loop.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+code size: 29
+ret: 0
+status: Ok(())

lang/tests/son_tests_different_types.txt

@@ -0,0 +1,30 @@
+main:
+    ADDI64 r254, r254, -12d
+    LI8 r1, 255b
+    ST r1, r254, 0a, 1h
+    LI8 r4, 0b
+    ST r4, r254, 1a, 1h
+    ST r4, r254, 2a, 1h
+    ST r1, r254, 3a, 1h
+    LI32 r9, 0w
+    ST r9, r254, 4a, 4h
+    LI32 r12, 2w
+    ST r12, r254, 8a, 4h
+    LD r3, r254, 8a, 4h
+    ANDI r3, r3, 4294967295d
+    ANDI r12, r12, 4294967295d
+    JEQ r3, r12, :0
+    LI64 r1, 0d
+    JMP :1
+ 0: LD r10, r254, 4a, 4h
+    ANDI r10, r10, 4294967295d
+    ANDI r9, r9, 4294967295d
+    JEQ r10, r9, :2
+    LI64 r1, 64d
+    JMP :1
+ 2: LI64 r1, 512d
+ 1: ADDI64 r254, r254, 12d
+    JALA r0, r31, 0a
+code size: 257
+ret: 512
+status: Ok(())

lang/tests/son_tests_directives.txt

@@ -0,0 +1,19 @@
+main:
+    ADDI64 r254, r254, -16d
+    LI64 r1, 10d
+    ADDI64 r4, r254, 0d
+    ST r1, r254, 0a, 8h
+    LI64 r7, 20d
+    ST r7, r254, 8a, 8h
+    LI64 r6, 6d
+    LI64 r5, 5d
+    LI64 r2, 1d
+    LD r3, r4, 0a, 16h
+    ECA 
+    LI64 r1, 0d
+    ADDI64 r254, r254, 16d
+    JALA r0, r31, 0a
+ev: Ecall
+code size: 152
+ret: 0
+status: Ok(())

lang/tests/son_tests_exhaustive_loop_testing.txt

@@ -0,0 +1,105 @@
+continue_and_state_change:
+    LI64 r7, 3d
+    LI64 r8, 4d
+    LI64 r9, 2d
+    LI64 r10, 10d
+ 6: JLTU r2, r10, :0
+    CP r1, r2
+    JMP :1
+ 0: JNE r2, r9, :2
+    CP r2, r8
+    JMP :3
+ 2: JNE r2, r7, :4
+    LI64 r1, 0d
+ 1: JMP :5
+ 4: ADDI64 r2, r2, 1d
+ 3: JMP :6
+ 5: JALA r0, r31, 0a
+infinite_loop:
+    ADDI64 r254, r254, -24d
+    ST r31, r254, 0a, 24h
+    LI64 r32, 1d
+    LI64 r33, 0d
+    CP r1, r33
+ 1: JNE r1, r32, :0
+    JMP :0
+ 0: CP r2, r33
+    JAL r31, r0, :continue_and_state_change
+    JMP :1
+    LD r31, r254, 0a, 24h
+    ADDI64 r254, r254, 24d
+    JALA r0, r31, 0a
+main:
+    ADDI64 r254, r254, -56d
+    ST r31, r254, 0a, 56h
+    LI64 r32, 0d
+    CP r2, r32
+    JAL r31, r0, :multiple_breaks
+    CP r2, r1
+    LI64 r1, 3d
+    JEQ r2, r1, :0
+    LI64 r1, 1d
+    JMP :1
+ 0: CP r33, r1
+    LI64 r34, 4d
+    CP r2, r34
+    JAL r31, r0, :multiple_breaks
+    CP r35, r34
+    LI64 r36, 10d
+    JEQ r1, r36, :2
+    LI64 r1, 2d
+    JMP :1
+ 2: CP r2, r32
+    JAL r31, r0, :state_change_in_break
+    JEQ r1, r32, :3
+    CP r1, r33
+    JMP :1
+ 3: CP r2, r35
+    JAL r31, r0, :state_change_in_break
+    JEQ r1, r36, :4
+    CP r1, r35
+    JMP :1
+ 4: CP r2, r36
+    JAL r31, r0, :continue_and_state_change
+    JEQ r1, r36, :5
+    LI64 r1, 5d
+    JMP :1
+ 5: CP r2, r33
+    JAL r31, r0, :continue_and_state_change
+    JEQ r1, r32, :6
+    LI64 r1, 6d
+    JMP :1
+ 6: CP r37, r32
+    JAL r31, r0, :infinite_loop
+    CP r1, r37
+ 1: LD r31, r254, 0a, 56h
+    ADDI64 r254, r254, 56d
+    JALA r0, r31, 0a
+multiple_breaks:
+    LI64 r6, 3d
+    LI64 r5, 10d
+ 4: JLTU r2, r5, :0
+    CP r1, r2
+    JMP :1
+ 0: ADDI64 r1, r2, 1d
+    JNE r1, r6, :2
+ 1: JMP :3
+ 2: CP r2, r1
+    JMP :4
+ 3: JALA r0, r31, 0a
+state_change_in_break:
+    LI64 r5, 3d
+    LI64 r6, 10d
+ 4: JLTU r2, r6, :0
+    CP r1, r2
+    JMP :1
+ 0: JNE r2, r5, :2
+    LI64 r1, 0d
+ 1: JMP :3
+ 2: ADDI64 r2, r2, 1d
+    JMP :4
+ 3: JALA r0, r31, 0a
+timed out
+code size: 668
+ret: 10
+status: Ok(())

lang/tests/son_tests_fb_driver.txt

@@ -0,0 +1,55 @@
+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
+main:
+    ADDI64 r254, r254, -48d
+    ST r31, r254, 0a, 48h
+    JAL r31, r0, :check_platform
+    LI64 r32, 0d
+    LI64 r33, 30d
+    LI64 r34, 100d
+    CP r10, r32
+    CP r35, r32
+    CP r36, r32
+ 5: JLTU r10, r33, :0
+    ADDI64 r35, r35, 1d
+    CP r2, r32
+    CP r3, r35
+    CP r4, r33
+    JAL r31, r0, :set_pixel
+    CP r2, r36
+    JEQ r1, r2, :1
+    CP r1, r32
+    JMP :2
+ 1: CP r5, r32
+    CP r36, r2
+    JNE r35, r34, :3
+    CP r1, r36
+    JMP :2
+ 3: CP r1, r36
+    CP r10, r5
+    JMP :4
+ 0: CP r1, r36
+    CP r5, r32
+    ADDI64 r1, r1, 1d
+    ADDI64 r10, r10, 1d
+ 4: CP r32, r5
+    CP r36, r1
+    JMP :5
+ 2: LD r31, r254, 0a, 48h
+    ADDI64 r254, r254, 48d
+    JALA r0, r31, 0a
+set_pixel:
+    MUL64 r7, r3, r4
+    ADD64 r1, r7, r2
+    JALA r0, r31, 0a
+x86_fb_ptr:
+    LI64 r1, 100d
+    JALA r0, r31, 0a
+code size: 336
+ret: 3000
+status: Ok(())

lang/tests/son_tests_floating_point_arithmetic.txt

@@ -0,0 +1,6 @@
+main:
+    LI32 r1, 3212836864w
+    JALA r0, r31, 0a
+code size: 25
+ret: 3212836864
+status: Ok(())

lang/tests/son_tests_functions.txt

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

lang/tests/son_tests_generic_functions.txt

@@ -0,0 +1,25 @@
+add:
+    ADD64 r1, r2, r3
+    JALA r0, r31, 0a
+add:
+    ADD32 r1, r2, r3
+    JALA r0, r31, 0a
+main:
+    ADDI64 r254, r254, -16d
+    ST r31, r254, 0a, 16h
+    LI32 r3, 2w
+    CP r2, r3
+    JAL r31, r0, :add
+    CP r32, r1
+    LI64 r3, 3d
+    LI64 r2, 1d
+    JAL r31, r0, :add
+    CP r2, r32
+    ANDI r11, r2, 4294967295d
+    SUB64 r1, r11, r1
+    LD r31, r254, 0a, 16h
+    ADDI64 r254, r254, 16d
+    JALA r0, r31, 0a
+code size: 161
+ret: 0
+status: Ok(())

lang/tests/son_tests_generic_types.txt

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

lang/tests/son_tests_global_aliasing_overptimization.txt

@@ -0,0 +1,19 @@
+clobber:
+    LRA r1, r0, :var
+    LI64 r3, 0d
+    ST r3, r1, 0a, 8h
+    JALA r0, r31, 0a
+main:
+    ADDI64 r254, r254, -16d
+    ST r31, r254, 0a, 16h
+    LRA r32, r0, :var
+    LI64 r3, 2d
+    ST r3, r32, 0a, 8h
+    JAL r31, r0, :clobber
+    LD r1, r32, 0a, 8h
+    LD r31, r254, 0a, 16h
+    ADDI64 r254, r254, 16d
+    JALA r0, r31, 0a
+code size: 166
+ret: 0
+status: Ok(())

lang/tests/son_tests_global_variables.txt

@@ -0,0 +1,9 @@
+main:
+    LRA r2, r0, :complex_global_var
+    LD r3, r2, 0a, 8h
+    ADDI64 r1, r3, 5d
+    ST r1, r2, 0a, 8h
+    JALA r0, r31, 0a
+code size: 71
+ret: 55
+status: Ok(())

lang/tests/son_tests_hex_octal_binary_literals.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+code size: 29
+ret: 0
+status: Ok(())

lang/tests/son_tests_idk.txt

@@ -0,0 +1,20 @@
+main:
+    ADDI64 r254, r254, -128d
+    LI8 r5, 69b
+    LI64 r6, 128d
+    LI64 r7, 0d
+    ADDI64 r4, r254, 0d
+ 2: LD r12, r254, 42a, 1h
+    JLTU r7, r6, :0
+    ANDI r1, r12, 255d
+    JMP :1
+ 0: ADDI64 r3, r7, 1d
+    ADD64 r7, r4, r7
+    ST r5, r7, 0a, 1h
+    CP r7, r3
+    JMP :2
+ 1: ADDI64 r254, r254, 128d
+    JALA r0, r31, 0a
+code size: 145
+ret: 69
+status: Ok(())

lang/tests/son_tests_if_statements.txt

@@ -0,0 +1,31 @@
+fib:
+    ADDI64 r254, r254, -32d
+    ST r31, r254, 0a, 32h
+    LI64 r1, 1d
+    LI64 r32, 2d
+    JGTU r2, r32, :0
+    JMP :1
+ 0: CP r6, r2
+    SUB64 r2, r6, r1
+    CP r33, r6
+    JAL r31, r0, :fib
+    CP r2, r33
+    CP r34, r1
+    SUB64 r2, r2, r32
+    JAL r31, r0, :fib
+    CP r8, r34
+    ADD64 r1, r1, r8
+ 1: LD r31, r254, 0a, 32h
+    ADDI64 r254, r254, 32d
+    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: 214
+ret: 55
+status: Ok(())

lang/tests/son_tests_infinite_loop_after_peephole.txt

@@ -0,0 +1,9 @@
+main:
+    LI64 r2, 0d
+ 0: ADDI64 r2, r2, 1d
+    JMP :0
+    JALA r0, r31, 0a
+timed out
+code size: 45
+ret: 0
+status: Ok(())

lang/tests/son_tests_inline.txt

@@ -0,0 +1,18 @@
+main:
+    LI64 r7, 6d
+    LRA r3, r0, :gb
+    LI64 r6, 0d
+    LD r8, r3, 0a, 8h
+    CMPU r9, r8, r6
+    CMPUI r9, r9, 0d
+    ORI r11, r9, 0d
+    ANDI r11, r11, 255d
+    JNE r11, r0, :0
+    CP r4, r7
+    JMP :1
+ 0: LI64 r4, 1d
+ 1: SUB64 r1, r4, r7
+    JALA r0, r31, 0a
+code size: 131
+ret: 0
+status: Ok(())

lang/tests/son_tests_inline_test.txt

@@ -0,0 +1,40 @@
+main:
+    ADDI64 r254, r254, -16d
+    ST r31, r254, 0a, 16h
+    JAL r31, r0, :scalar_values
+    LI64 r3, 0d
+    CP r8, r3
+    JEQ r1, r8, :0
+    LI64 r1, 1d
+    JMP :1
+ 0: CP r32, r8
+    JAL r31, r0, :structs
+    CP r3, r32
+    JEQ r1, r3, :2
+    JAL r31, r0, :structs
+    JMP :1
+ 2: CP r1, r3
+    CP r32, r3
+ 1: LD r31, r254, 0a, 16h
+    ADDI64 r254, r254, 16d
+    JALA r0, r31, 0a
+scalar_values:
+    LI64 r1, 0d
+    JALA r0, r31, 0a
+structs:
+    ADDI64 r254, r254, -32d
+    LI64 r2, 5d
+    ST r2, r254, 16a, 8h
+    ST r2, r254, 24a, 8h
+    LD r6, r254, 16a, 8h
+    ADDI64 r8, r6, 15d
+    ST r8, r254, 0a, 8h
+    LI64 r7, 20d
+    ST r7, r254, 8a, 8h
+    LD r1, r254, 0a, 8h
+    SUB64 r1, r1, r7
+    ADDI64 r254, r254, 32d
+    JALA r0, r31, 0a
+code size: 310
+ret: 0
+status: Ok(())

lang/tests/son_tests_inlined_generic_functions.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 10d
+    JALA r0, r31, 0a
+code size: 29
+ret: 10
+status: Ok(())

lang/tests/son_tests_intcast_store.txt

@@ -0,0 +1,20 @@
+main:
+    ADDI64 r254, r254, -24d
+    ST r31, r254, 16a, 8h
+    ADDI64 r3, r254, 0d
+    ADDI64 r2, r254, 8d
+    LI64 r4, 0d
+    ST r4, r254, 0a, 8h
+    ST r4, r254, 8a, 8h
+    LI64 r4, 1024d
+    JAL r31, r0, :set
+    ANDI r1, r1, 4294967295d
+    LD r31, r254, 16a, 8h
+    ADDI64 r254, r254, 24d
+    JALA r0, r31, 0a
+set:
+    CP r1, r4
+    JALA r0, r31, 0a
+code size: 167
+ret: 1024
+status: Ok(())

lang/tests/son_tests_integer_inference_issues.txt

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

lang/tests/son_tests_loop_stores.txt

@@ -0,0 +1,16 @@
+main:
+    ADDI64 r254, r254, -8d
+    LI64 r3, 0d
+    LI64 r2, 10d
+    ST r2, r254, 0a, 8h
+ 2: LD r1, r254, 0a, 8h
+    JNE r1, r3, :0
+    JMP :1
+ 0: ADDI64 r11, r1, -1d
+    ST r11, r254, 0a, 8h
+    JMP :2
+ 1: ADDI64 r254, r254, 8d
+    JALA r0, r31, 0a
+code size: 126
+ret: 0
+status: Ok(())

lang/tests/son_tests_loops.txt

@@ -0,0 +1,25 @@
+fib:
+    LI64 r4, 1d
+    LI64 r5, 0d
+    CP r1, r5
+    CP r10, r4
+ 2: JNE r2, r5, :0
+    JMP :1
+ 0: ADD64 r1, r10, r1
+    SUB64 r2, r2, r4
+    CP r3, r1
+    CP r1, r10
+    CP r10, r3
+    JMP :2
+ 1: 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: 153
+ret: 55
+status: Ok(())

lang/tests/son_tests_main_fn.txt

@@ -0,0 +1,6 @@
+main:
+    LI64 r1, 1d
+    JALA r0, r31, 0a
+code size: 29
+ret: 1
+status: Ok(())

lang/tests/son_tests_nonexistent_ident_import.txt

@@ -0,0 +1,7 @@
+foo.hb:4:1: redeclaration of identifier: foo
+foo := fn(): void {
+^
+
+foo.hb:7:23: undefined indentifier: mian
+main := @use("bar.hb").mian
+                      ^

lang/tests/son_tests_nullable_types.txt

@@ -0,0 +1,87 @@
+decide:
+    LI8 r1, 1b
+    JALA r0, r31, 0a
+main:
+    ADDI64 r254, r254, -136d
+    ST r31, r254, 80a, 56h
+    JAL r31, r0, :decide
+    LI64 r4, 0d
+    ADDI64 r32, r254, 72d
+    ANDI r1, r1, 255d
+    JNE r1, r0, :0
+    CP r33, r4
+    JMP :1
+ 0: CP r33, r32
+ 1: JNE r33, r4, :2
+    LI64 r1, 9001d
+    JMP :3
+ 2: JAL r31, r0, :decide
+    LI8 r34, 0b
+    LI8 r35, 1b
+    ANDI r1, r1, 255d
+    JNE r1, r0, :4
+    ST r35, r254, 56a, 1h
+    LD r9, r33, 0a, 8h
+    ST r9, r254, 64a, 8h
+    JMP :5
+ 4: ST r34, r254, 56a, 1h
+ 5: LD r6, r254, 56a, 1h
+    ANDI r6, r6, 255d
+    ANDI r34, r34, 255d
+    JEQ r6, r34, :6
+    LI64 r1, 42d
+    JMP :3
+ 6: JAL r31, r0, :decide
+    LI32 r2, 0w
+    ANDI r1, r1, 255d
+    JNE r1, r0, :7
+    CP r36, r2
+    JMP :8
+ 7: LI32 r36, 8388609w
+ 8: ANDI r36, r36, 4294967295d
+    ANDI r2, r2, 4294967295d
+    JNE r36, r2, :9
+    LI64 r1, 69d
+    JMP :3
+ 9: JAL r31, r0, :decide
+    LI64 r3, 0d
+    LI64 r37, 1d
+    ANDI r1, r1, 255d
+    JNE r1, r0, :10
+    ST r3, r254, 16a, 8h
+    JMP :11
+10: ST r32, r254, 16a, 8h
+    ST r37, r254, 24a, 8h
+    ST r37, r254, 72a, 8h
+11: LD r2, r254, 16a, 8h
+    JNE r2, r3, :12
+    LI64 r1, 34d
+    JMP :3
+12: JAL r31, r0, :decide
+    ADDI64 r10, r254, 32d
+    ANDI r1, r1, 255d
+    JNE r1, r0, :13
+    ADDI64 r11, r254, 0d
+    ST r32, r254, 0a, 8h
+    ST r37, r254, 8a, 8h
+    ST r35, r254, 32a, 1h
+    ADDI64 r12, r10, 8d
+    BMC r11, r12, 16h
+    JMP :14
+13: ST r34, r254, 32a, 1h
+14: LD r11, r254, 32a, 1h
+    ANDI r11, r11, 255d
+    ANDI r34, r34, 255d
+    JEQ r11, r34, :15
+    LI64 r1, 420d
+    JMP :3
+15: LD r5, r254, 16a, 8h
+    LD r7, r5, 0a, 8h
+    ANDI r9, r36, 65535d
+    SUB64 r1, r9, r7
+ 3: LD r31, r254, 80a, 56h
+    ADDI64 r254, r254, 136d
+    JALA r0, r31, 0a
+code size: 729
+ret: 0
+status: Ok(())