fixing feature incompatibility

.cargo/config.toml

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

.gitignore

@@ -3,3 +3,4 @@
 /.rgignore
 rustc-ice-*
 db.sqlite
+/depell/src/*.wasm

Cargo.lock

@@ -810,6 +810,9 @@ name = "wasm-hbc"
 version = "0.1.0"
 dependencies = [
  "hblang",
+ "hbvm",
+ "log",
+ "wasm-rt",
 ]
 
 [[package]]
@@ -817,6 +820,14 @@ name = "wasm-hbfmt"
 version = "0.1.0"
 dependencies = [
  "hblang",
+ "wasm-rt",
+]
+
+[[package]]
+name = "wasm-rt"
+version = "0.1.0"
+dependencies = [
+ "log",
 ]
 
 [[package]]

Cargo.toml

@@ -1,3 +1,5 @@
+cargo-features = ["profile-rustflags"]
+
 [workspace]
 resolver = "2"
 members = [
@@ -9,11 +11,12 @@ members = [
 	"depell",
 	"depell/wasm-fmt",
 	"depell/wasm-hbc",
+	"depell/wasm-rt",
 ]
 
 [workspace.dependencies]
 hbbytecode = { path = "bytecode", default-features = false }
-hbvm = { path = "vm" }
+hbvm = { path = "vm", default-features = false }
 hbxrt = { path = "xrt" }
 hblang = { path = "lang", default-features = false }
 hbjit = { path = "jit" }
@@ -26,9 +29,13 @@ codegen-units = 1
 panic = "abort"
 
 [profile.small]
+#rustflags = ["-Zfmt-debug=none", "-Zlocation-detail=none"]
 inherits = "release"
 opt-level = "z"
-strip = true
+strip = "debuginfo"
+#strip = true
 lto = true
 codegen-units = 1
 panic = "abort"
+
+

depell/src/index.css

@@ -54,9 +54,6 @@ form {
 	flex-direction: column;
 	gap: var(--small-gap);
 
-	::placeholder {
-		color: var(--placeholder);
-	}
 
 	.error {
 		color: var(--error);

depell/src/index.js

@@ -3,19 +3,82 @@
 /** @return {never} */
 function never() { throw new Error() }
 
-/**@type{WebAssembly.Instance}*/ let instance;
+/**@type{WebAssembly.Instance}*/ let hbcInstance;
-/**@type{Promise<WebAssembly.WebAssemblyInstantiatedSource>}*/ let instaceFuture;
+/**@type{Promise<WebAssembly.WebAssemblyInstantiatedSource>}*/ let hbcInstaceFuture;
+/** @param {Uint8Array} code @param {number} fuel
+ * @returns {Promise<string | undefined> | string | undefined} */
+function compileCode(code, fuel) {
+	if (!hbcInstance) {
+		hbcInstaceFuture ??= WebAssembly.instantiateStreaming(fetch("/hbc.wasm"), {});
+		return (async () => {
+			hbcInstance = (await hbcInstaceFuture).instance;
+			return compileCodeSync(hbcInstance, code, fuel);
+		})();
+	} else {
+		return compileCodeSync(hbcInstance, code, fuel);
+	}
+
+}
+
+/** @param {WebAssembly.Instance} instance @param {Uint8Array} code @param {number} fuel @returns {string | undefined} */
+function compileCodeSync(instance, code, fuel) {
+	let {
+		INPUT, INPUT_LEN,
+		LOG_MESSAGES, LOG_MESSAGES_LEN,
+		PANIC_MESSAGE, PANIC_MESSAGE_LEN,
+		memory, compile_and_run
+	} = instance.exports;
+
+	if (!(true
+		&& INPUT instanceof WebAssembly.Global
+		&& INPUT_LEN instanceof WebAssembly.Global
+		&& LOG_MESSAGES instanceof WebAssembly.Global
+		&& LOG_MESSAGES_LEN instanceof WebAssembly.Global
+		&& memory instanceof WebAssembly.Memory
+		&& typeof compile_and_run === "function"
+	)) console.log(instance.exports), never();
+
+	const dw = new DataView(memory.buffer);
+	dw.setUint32(INPUT_LEN.value, code.length, true);
+	new Uint8Array(memory.buffer, INPUT.value).set(code);
+
+	try {
+		compile_and_run(fuel);
+		return bufToString(memory, LOG_MESSAGES, LOG_MESSAGES_LEN);
+	} catch (e) {
+		if (PANIC_MESSAGE instanceof WebAssembly.Global
+			&& PANIC_MESSAGE_LEN instanceof WebAssembly.Global) {
+			console.error(bufToString(memory, PANIC_MESSAGE, PANIC_MESSAGE_LEN));
+		}
+		let log = bufToString(memory, LOG_MESSAGES, LOG_MESSAGES_LEN);
+		console.error(log, e);
+		return undefined;
+	}
+}
+
+/** @param {WebAssembly.Memory} mem
+ * @param {WebAssembly.Global} ptr
+ * @param {WebAssembly.Global} len
+ * @return {string} */
+function bufToString(mem, ptr, len) {
+	return new TextDecoder()
+		.decode(new Uint8Array(mem.buffer, ptr.value,
+			new DataView(mem.buffer).getUint32(len.value, true)));
+}
+
+/**@type{WebAssembly.Instance}*/ let fmtInstance;
+/**@type{Promise<WebAssembly.WebAssemblyInstantiatedSource>}*/ let fmtInstaceFuture;
 /** @param {string} code @param {"fmt" | "minify"} action
  * @returns {Promise<string | undefined> | string | undefined} */
 function modifyCode(code, action) {
-	if (!instance) {
+	if (!fmtInstance) {
-		instaceFuture ??= WebAssembly.instantiateStreaming(fetch("/hbfmt.wasm"), {});
+		fmtInstaceFuture ??= WebAssembly.instantiateStreaming(fetch("/hbfmt.wasm"), {});
 		return (async () => {
-			instance = (await instaceFuture).instance;
+			fmtInstance = (await fmtInstaceFuture).instance;
-			return modifyCodeSync(instance, code, action);
+			return modifyCodeSync(fmtInstance, code, action);
 		})();
 	} else {
-		return modifyCodeSync(instance, code, action);
+		return modifyCodeSync(fmtInstance, code, action);
 	}
 }
 
@@ -100,11 +163,15 @@ function bindTextareaAutoResize(target) {
 	for (const textarea of target.querySelectorAll("textarea")) {
 		if (!(textarea instanceof HTMLTextAreaElement)) never();
 
-		textarea.style.height = textarea.scrollHeight + "px";
+		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() {
 			textarea.style.height = "auto";
-			textarea.style.height = textarea.scrollHeight + "px";
+			textarea.style.height = (textarea.scrollHeight - padding) + "px";
 		});
 
 		textarea.onkeydown = (ev) => {
@@ -112,10 +179,7 @@ function bindTextareaAutoResize(target) {
 
 			if (ev.key === "Tab") {
 				ev.preventDefault();
-				const prevPos = textarea.selectionStart;
+				document.execCommand('insertText', false, "    ");
-				textarea.value = textarea.value.slice(0, textarea.selectionStart) +
-					'    ' + textarea.value.slice(textarea.selectionEnd);
-				textarea.selectionStart = textarea.selectionEnd = prevPos + 4;
 			}
 
 			if (ev.key === "Backspace" && textarea.selectionStart != 0 && !selecting) {
@@ -125,10 +189,8 @@ function bindTextareaAutoResize(target) {
 					ev.preventDefault();
 					let toDelete = (textarea.selectionStart - (i + 1)) % 4;
 					if (toDelete === 0) toDelete = 4;
-					const prevPos = textarea.selectionStart;
+					textarea.selectionStart -= toDelete;
-					textarea.value = textarea.value.slice(0, textarea.selectionStart - toDelete) +
+					document.execCommand('delete', false);
-						textarea.value.slice(textarea.selectionEnd);
-					textarea.selectionStart = textarea.selectionEnd = prevPos - toDelete;
 				}
 			}
 		}
@@ -165,11 +227,27 @@ if (window.location.hostname === 'localhost') {
 		if (id !== new_id) window.location.reload();
 	}, 300);
 
-	(async function testCodeChange() {
+	(async function test() {
+		{
 			const code = "main:=fn():void{return}";
 			const fmtd = await modifyCode(code, "fmt") ?? never();
 			const prev = await modifyCode(fmtd, "minify") ?? never();
 			if (code != prev) console.error(code, prev);
+		}
+		{
+
+			const name = "foo.hb";
+			const code = "main:=fn():void{return 42}";
+			const buf = new Uint8Array(2 + name.length + 2 + code.length);
+			const view = new DataView(buf.buffer);
+			view.setUint16(0, name.length, true);
+			buf.set(new TextEncoder().encode(name), 2);
+			view.setUint16(2 + name.length, code.length, true);
+			buf.set(new TextEncoder().encode(code), 2 + name.length + 2);
+			const res = await compileCode(buf, 1) ?? never();
+			const expected = "";
+			if (expected != res) console.error(expected, res);
+		}
 	})()
 }
 

depell/src/main.rs

@@ -40,6 +40,8 @@ async fn amain() {
 
     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!(
@@ -47,6 +49,13 @@ async fn amain() {
                 "../../target/wasm32-unknown-unknown/small/wasm_hbfmt.wasm"
             ),
         )
+        .route(
+            "/hbc.wasm",
+            static_asset!(
+                "application/wasm",
+                "../../target/wasm32-unknown-unknown/small/wasm_hbc.wasm"
+            ),
+        )
         .route("/index-view", get(Index::get))
         .route("/feed", get(Index::page))
         .route("/profile", get(Profile::page))
@@ -377,7 +386,7 @@ async fn base(body: impl FnOnce(&mut String), session: Option<&Session>) -> Html
         "<!DOCTYPE html>"
         <html lang="en">
             <head>
-                <style>!{include_str!("index.css")}</style>
+                <link rel="stylesheet" href="/index.css">
             </head>
             <body>
                 <nav>
@@ -401,7 +410,7 @@ async fn base(body: impl FnOnce(&mut String), session: Option<&Session>) -> Html
                 <main>|f|{body(f)}</main>
             </body>
             <script src="https://unpkg.com/htmx.org@2.0.3" integrity="sha384-0895/pl2MU10Hqc6jd4RvrthNlDiE9U1tWmX7WRESftEDRosgxNsQG/Ze9YMRzHq" crossorigin="anonymous"></script>
-            <script>!{include_str!("index.js")}</script>
+            <script src="/index.js"></script>
         </html>
     })
 }

depell/wasm-fmt/Cargo.toml

@@ -8,3 +8,4 @@ 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

@@ -1,115 +1,16 @@
 #![no_std]
-#![feature(slice_take)]
 #![feature(str_from_raw_parts)]
 #![feature(alloc_error_handler)]
 
-use {
+use hblang::{fmt, parser};
-    core::{
+
-        alloc::{GlobalAlloc, Layout},
+wasm_rt::decl_runtime!(128 * 1024, 1024 * 4);
-        cell::UnsafeCell,
-    },
-    hblang::parser::ParserCtx,
-};
 
-const ARENA_SIZE: usize = 128 * 1024;
 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);
-#[cfg(target_arch = "wasm32")]
-#[panic_handler]
-pub fn handle_panic(_info: &core::panic::PanicInfo) -> ! {
-    //unsafe {
-    //    use core::fmt::Write;
-    //    let mut f = Write(&mut PANIC_MESSAGE[..]);
-    //    _ = writeln!(f, "{}", info);
-    //    PANIC_MESSAGE_LEN = 1024 - f.0.len();
-    //}
-
-    core::arch::wasm32::unreachable();
-}
-
-//#[no_mangle]
-//static mut PANIC_MESSAGE: [u8; 1024] = [0; 1024];
-//#[no_mangle]
-//static mut PANIC_MESSAGE_LEN: usize = 0;
-
-#[global_allocator]
-static ALLOCATOR: ArenaAllocator = ArenaAllocator::new();
-
-#[cfg(target_arch = "wasm32")]
-#[alloc_error_handler]
-fn alloc_error(_: core::alloc::Layout) -> ! {
-    core::arch::wasm32::unreachable()
-}
-
-#[repr(C, align(32))]
-struct ArenaAllocator {
-    arena: UnsafeCell<[u8; ARENA_SIZE]>,
-    head: UnsafeCell<*mut u8>,
-}
-
-impl ArenaAllocator {
-    const fn new() -> Self {
-        ArenaAllocator {
-            arena: UnsafeCell::new([0; ARENA_SIZE]),
-            head: UnsafeCell::new(core::ptr::null_mut()),
-        }
-    }
-
-    unsafe fn reset(&self) {
-        (*self.head.get()) = self.arena.get().cast::<u8>().add(ARENA_SIZE);
-    }
-}
-
-unsafe impl Sync for ArenaAllocator {}
-
-unsafe impl GlobalAlloc for ArenaAllocator {
-    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 & !(1 << (align - 1))) as *mut u8;
-
-        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 */
-    }
-}
-
-struct Write<'a>(&'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)
-        }
-    }
-}
-
-#[no_mangle]
-static mut OUTPUT: [u8; MAX_OUTPUT_SIZE] = [0; MAX_OUTPUT_SIZE];
-#[no_mangle]
-static mut OUTPUT_LEN: usize = 0;
-
-#[no_mangle]
-static MAX_INPUT: usize = MAX_INPUT_SIZE;
-#[no_mangle]
-static mut INPUT: [u8; MAX_INPUT_SIZE] = [0; MAX_INPUT_SIZE];
-#[no_mangle]
-static mut INPUT_LEN: usize = 0;
 
 #[no_mangle]
 unsafe extern "C" fn fmt() {
@@ -117,19 +18,17 @@ unsafe extern "C" fn fmt() {
 
     let code = core::str::from_raw_parts(core::ptr::addr_of!(INPUT).cast(), INPUT_LEN);
 
-    let arena =
+    let arena = parser::Arena::with_capacity(code.len() * parser::SOURCE_TO_AST_FACTOR);
-        hblang::parser::Arena::with_capacity(code.len() * hblang::parser::SOURCE_TO_AST_FACTOR);
+    let mut ctx = parser::ParserCtx::default();
-    let mut ctx = ParserCtx::default();
+    let exprs = parser::Parser::parse(&mut ctx, code, "source.hb", &mut |_, _| Ok(0), &arena);
-    let exprs =
-        hblang::parser::Parser::parse(&mut ctx, code, "source.hb", &mut |_, _| Ok(0), &arena);
 
-    let mut f = Write(&mut OUTPUT[..]);
+    let mut f = wasm_rt::Write(&mut OUTPUT[..]);
-    hblang::fmt::fmt_file(exprs, code, &mut f).unwrap();
+    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 = hblang::fmt::minify(code);
+    OUTPUT_LEN = fmt::minify(code);
 }

depell/wasm-hbc/Cargo.toml

@@ -7,4 +7,8 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-hblang.workspace = true
+hblang = { workspace = true, features = [] }
+hbvm.workspace = true
+log = "0.4.22"
+wasm-rt = { version = "0.1.0", path = "../wasm-rt", features = ["log"] }
+

depell/wasm-hbc/src/lib.rs

@@ -1,103 +1,26 @@
 #![feature(alloc_error_handler)]
+#![feature(slice_take)]
 #![no_std]
 
 use {
-    alloc::{borrow::ToOwned, string::String, vec::Vec},
+    alloc::{string::String, vec::Vec},
-    core::{
-        alloc::{GlobalAlloc, Layout},
-        cell::UnsafeCell,
-    },
     hblang::{codegen::Codegen, parser::FileId},
 };
 
 extern crate alloc;
 
-const ARENA_SIZE: usize = 4 * 128 * 1024;
+wasm_rt::decl_runtime!(128 * 8 * 1024, 1024 * 4);
-const MAX_PANIC_SIZE: usize = 1024 * 4;
+
 const MAX_INPUT_SIZE: usize = 32 * 4 * 1024;
-
+wasm_rt::decl_buffer!(MAX_INPUT_SIZE, MAX_INPUT, INPUT, INPUT_LEN);
-#[cfg(target_arch = "wasm32")]
-#[panic_handler]
-pub fn handle_panic(_info: &core::panic::PanicInfo) -> ! {
-    unsafe {
-        use core::fmt::Write;
-        let mut f = Write(&mut PANIC_MESSAGE[..]);
-        _ = writeln!(f, "{}", info);
-        PANIC_MESSAGE_LEN = 1024 - f.0.len();
-    }
-
-    core::arch::wasm32::unreachable();
-}
 
 #[no_mangle]
-static mut PANIC_MESSAGE: [u8; MAX_PANIC_SIZE] = [0; MAX_PANIC_SIZE];
+unsafe fn compile_and_run(mut fuel: usize) {
-#[no_mangle]
-static mut PANIC_MESSAGE_LEN: usize = 0;
-
-#[global_allocator]
-static ALLOCATOR: ArenaAllocator = ArenaAllocator::new();
-
-#[cfg(target_arch = "wasm32")]
-#[alloc_error_handler]
-fn alloc_error(_: core::alloc::Layout) -> ! {
-    core::arch::wasm32::unreachable()
-}
-
-#[repr(C, align(32))]
-struct ArenaAllocator {
-    arena: UnsafeCell<[u8; ARENA_SIZE]>,
-    head: UnsafeCell<*mut u8>,
-}
-
-impl ArenaAllocator {
-    const fn new() -> Self {
-        ArenaAllocator {
-            arena: UnsafeCell::new([0; ARENA_SIZE]),
-            head: UnsafeCell::new(core::ptr::null_mut()),
-        }
-    }
-
-    unsafe fn reset(&self) {
-        (*self.head.get()) = self.arena.get().cast::<u8>().add(ARENA_SIZE);
-    }
-}
-
-unsafe impl Sync for ArenaAllocator {}
-
-unsafe impl GlobalAlloc for ArenaAllocator {
-    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 & !(1 << (align - 1))) as *mut u8;
-
-        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 */
-    }
-}
-
-#[no_mangle]
-static MAX_INPUT: usize = MAX_INPUT_SIZE;
-#[no_mangle]
-static mut INPUT_LEN: usize = 0;
-#[no_mangle]
-static mut INPUT: [u8; MAX_INPUT_SIZE] = [0; MAX_INPUT_SIZE];
-
-#[no_mangle]
-unsafe fn compile_and_run() {
     ALLOCATOR.reset();
 
+    log::set_logger(&wasm_rt::Logger).unwrap();
+    log::set_max_level(log::LevelFilter::Error);
+
     struct File<'a> {
         path: &'a str,
         code: &'a mut str,
@@ -118,7 +41,8 @@ unsafe fn compile_and_run() {
             });
             input_bytes = rest;
         }
-        files.sort_unstable_by_key(|f| f.path);
+
+        hblang::quad_sort(&mut files, |a, b| a.path.cmp(b.path));
         files
     };
 
@@ -140,12 +64,29 @@ unsafe fn compile_and_run() {
             .collect::<Vec<_>>()
     };
 
-    let code = {
+    let mut ct = {
         let mut c = Codegen::default();
         c.files = files;
         c.generate();
-        let mut buf = Vec::with_capacity(1024 * 8);
+        c.assemble_comptime()
-        c.assemble(&mut buf);
-        buf
     };
+
+    while fuel != 0 {
+        match ct.vm.run() {
+            Ok(hbvm::VmRunOk::End) => {
+                log::error!("exit code: {}", ct.vm.read_reg(1).0);
+                break;
+            }
+            Ok(hbvm::VmRunOk::Ecall) => {
+                let unknown = ct.vm.read_reg(2).0;
+                log::error!("unknown ecall: {unknown}")
+            }
+            Ok(hbvm::VmRunOk::Timer) => fuel -= 1,
+            Ok(hbvm::VmRunOk::Breakpoint) => todo!(),
+            Err(e) => {
+                log::error!("vm error: {e}");
+                break;
+            }
+        }
+    }
 }

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,144 @@
+#![feature(alloc_error_handler)]
+#![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(target_arch = "wasm32")]
+        #[panic_handler]
+        pub fn handle_panic(_info: &core::panic::PanicInfo) -> ! {
+            #[cfg(debug_assertions)]
+            {
+                #[no_mangle]
+                static mut PANIC_MESSAGE: [u8; $max_panic_size] = [0; $max_panic_size];
+                #[no_mangle]
+                static mut PANIC_MESSAGE_LEN: usize = 0;
+
+                unsafe {
+                    use core::fmt::Write;
+                    let mut f = Write(&mut PANIC_MESSAGE[..]);
+                    _ = writeln!(f, "{}", _info);
+                    PANIC_MESSAGE_LEN = 1024 - 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) -> ! {
+            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 * 4;
+            #[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> {
+    #[allow(clippy::new_without_default)]
+    pub const fn new() -> Self {
+        ArenaAllocator {
+            arena: UnsafeCell::new([0; SIZE]),
+            head: UnsafeCell::new(core::ptr::null_mut()),
+        }
+    }
+
+    #[allow(clippy::missing_safety_doc)]
+    pub unsafe fn reset(&self) {
+        (*self.head.get()) = self.arena.get().cast::<u8>().add(SIZE);
+    }
+}
+
+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 & !(1 << (align - 1))) as *mut u8;
+
+        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)
+        }
+    }
+}

lang/Cargo.toml

@@ -11,7 +11,7 @@ path = "src/main.rs"
 hashbrown = { version = "0.15.0", default-features = false, features = ["raw-entry"] }
 hbbytecode = { workspace = true, features = ["disasm"] }
 hbvm = { workspace = true, features = ["nightly"] }
-log = { version = "0.4.22", features = ["release_max_level_error"] }
+log = "0.4.22"
 
 [dependencies.regalloc2]
 git = "https://github.com/jakubDoka/regalloc2"

lang/README.md

@@ -169,16 +169,16 @@ main := fn(): int {
 	}
 
 	finst := Ty2.{ty: .{a: 4, b: 1}, c: 3}
-	//inst := odher_pass(finst)
+	inst := odher_pass(finst)
-	//if finst.c == 3 {
+	if inst.c == 3 {
-	//return finst.ty.a - finst.ty.b
+		return pass(&inst.ty)
-	return pass(&finst.ty)
+	}
-	//}
+	return 0
-	//return 0
 }
 
 pass := fn(t: ^Ty): int {
-	return t.a - t.b
+	.{a, b} := *t
+	return a - b
 }
 
 odher_pass := fn(t: Ty2): Ty2 {

lang/src/codegen.rs

@@ -8,7 +8,7 @@ use {
             self, find_symbol, idfl, CommentOr, CtorField, Expr, ExprRef, FileId, Pos, StructField,
         },
         ty, Field, Func, Global, LoggedMem, OffsetIter, ParamAlloc, Reloc, Sig, Struct, SymKey,
-        TypedReloc, Types,
+        TypedReloc, Types, HEADER_SIZE,
     },
     alloc::{boxed::Box, string::String, vec::Vec},
     core::fmt::Display,
@@ -637,11 +637,19 @@ struct Pool {
 
 const VM_STACK_SIZE: usize = 1024 * 64;
 
-struct Comptime {
+pub struct Comptime {
-    vm: hbvm::Vm<LoggedMem, { 1024 * 10 }>,
+    pub vm: hbvm::Vm<LoggedMem, { 1024 * 10 }>,
-    _stack: Box<[u8; VM_STACK_SIZE]>,
+    stack: Box<[u8; VM_STACK_SIZE]>,
     code: Vec<u8>,
 }
+impl Comptime {
+    fn reset(&mut self) {
+        let ptr = unsafe { self.stack.as_mut_ptr().cast::<u8>().add(VM_STACK_SIZE) as u64 };
+        self.vm.registers.fill(hbvm::value::Value(0));
+        self.vm.write_reg(STACK_PTR, ptr);
+        self.vm.pc = hbvm::mem::Address::new(self.code.as_ptr() as u64 + HEADER_SIZE as u64);
+    }
+}
 
 impl Default for Comptime {
     fn default() -> Self {
@@ -649,7 +657,7 @@ impl Default for Comptime {
         let mut vm = hbvm::Vm::default();
         let ptr = unsafe { stack.as_mut_ptr().cast::<u8>().add(VM_STACK_SIZE) as u64 };
         vm.write_reg(STACK_PTR, ptr);
-        Self { vm, _stack: unsafe { stack.assume_init() }, code: Default::default() }
+        Self { vm, stack: unsafe { stack.assume_init() }, code: Default::default() }
     }
 }
 
@@ -1233,9 +1241,12 @@ impl Codegen {
                             e => unimplemented!("{e:?}"),
                         }
                     }
-                    smh => self.report(
+                    _ => self.report(
                         target.pos(),
-                        format_args!("the field operation is not supported: {smh:?}"),
+                        format_args!(
+                            "the field operation is not supported: {}",
+                            self.ty_display(tal.ty)
+                        ),
                     ),
                 }
             }
@@ -1456,8 +1467,7 @@ impl Codegen {
                         self.report(
                             pos,
                             format_args!(
-                                "this integer was inferred to be '{}' \
+                                "this integer was inferred to be '{}'",
-                                which does not make sense",
                                 self.ty_display(ty)
                             ),
                         );
@@ -1715,16 +1725,11 @@ impl Codegen {
                 unimplemented!("{:#?}", op)
             }
             E::Comment { .. } => Some(Value::void()),
-            ref ast => self.report_unhandled_ast(ast, "expression"),
+            ref ast => self.report_unhandled_ast(ast, "something"),
         }?;
 
         if let Some(ty) = ctx.ty {
-            _ = self.assert_ty(
+            _ = self.assert_ty(expr.pos(), value.ty, ty, "somehow");
-                expr.pos(),
-                value.ty,
-                ty,
-                format_args!("'{}'", self.ast_display(expr)),
-            );
         }
 
         Some(match ctx.loc {
@@ -2666,7 +2671,7 @@ impl Codegen {
 
     fn run_vm(&mut self) {
         loop {
-            match self.ct.vm.run().unwrap() {
+            match self.ct.vm.run().unwrap_or_else(|e| panic!("{e:?}")) {
                 hbvm::VmRunOk::End => break,
                 hbvm::VmRunOk::Timer => unreachable!(),
                 hbvm::VmRunOk::Ecall => self.handle_ecall(),
@@ -2702,26 +2707,16 @@ impl Codegen {
         }
     }
 
-    fn report_log(&self, pos: Pos, msg: impl core::fmt::Display) {
-        log::error!("{}", self.cfile().report(pos, msg));
-    }
-
     #[track_caller]
     fn report(&self, pos: Pos, msg: impl core::fmt::Display) -> ! {
-        self.report_log(pos, msg);
+        log::error!("{}", self.cfile().report(pos, msg));
         unreachable!();
     }
 
     #[track_caller]
     fn report_unhandled_ast(&self, ast: &Expr, hint: &str) -> ! {
         log::debug!("{ast:#?}");
-        self.report(
+        self.report(ast.pos(), format_args!("compiler does not (yet) know how to handle ({hint})",))
-            ast.pos(),
-            format_args!(
-                "compiler does not (yet) know how to handle ({hint}):\n{}",
-                self.ast_display(ast)
-            ),
-        )
     }
 
     fn cfile(&self) -> &parser::Ast {
@@ -2753,9 +2748,14 @@ impl Codegen {
     }
 
     pub fn assemble(&mut self, buf: &mut Vec<u8>) {
-        self.tys.ins.funcs.iter_mut().for_each(|f| f.offset = u32::MAX);
+        self.tys.reassemble(buf);
-        self.tys.ins.globals.iter_mut().for_each(|g| g.offset = u32::MAX);
+    }
-        self.tys.assemble(buf)
+
+    pub fn assemble_comptime(mut self) -> Comptime {
+        self.ct.code.clear();
+        self.tys.reassemble(&mut self.ct.code);
+        self.ct.reset();
+        self.ct
     }
 }
 

lang/src/fmt.rs

@@ -6,6 +6,26 @@ use {
     core::fmt,
 };
 
+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..)
@@ -16,7 +36,7 @@ pub fn minify(source: &mut str) -> usize {
     let mut prev_needs_whitecpace = false;
     let mut prev_needs_newline = false;
     loop {
-        let mut token = lexer::Lexer::new(reader).next();
+        let mut token = lexer::Lexer::new(reader).eat();
         match token.kind {
             TokenKind::Eof => break,
             TokenKind::CtIdent | TokenKind::Directive => token.start -= 1,
@@ -321,25 +341,6 @@ impl<'a> Formatter<'a> {
                 self.fmt_list(f, true, "}", "", stmts, Self::fmt)
             }
             Expr::Number { value, radix, .. } => {
-                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!()
-                }
                 f.write_str(match radix {
                     Radix::Decimal => "",
                     Radix::Hex => "0x",
@@ -404,7 +405,7 @@ pub fn preserve_newlines(source: &str) -> usize {
 }
 
 pub fn insert_needed_semicolon(source: &str) -> bool {
-    let kind = lexer::Lexer::new(source).next().kind;
+    let kind = lexer::Lexer::new(source).eat().kind;
     kind.precedence().is_some() || matches!(kind, TokenKind::Ctor | TokenKind::Tupl)
 }
 
@@ -450,15 +451,15 @@ pub mod test {
         minned.truncate(len);
 
         let ast = parser::Ast::new(ident, minned, &mut ParserCtx::default(), &mut |_, _| Ok(0));
-        log::error!(
+        //log::error!(
-            "{} / {} = {} | {} / {} = {}",
+        //    "{} / {} = {} | {} / {} = {}",
-            ast.mem.size(),
+        //    ast.mem.size(),
-            input.len(),
+        //    input.len(),
-            ast.mem.size() as f32 / input.len() as f32,
+        //    ast.mem.size() as f32 / input.len() as f32,
-            ast.mem.size(),
+        //    ast.mem.size(),
-            ast.file.len(),
+        //    ast.file.len(),
-            ast.mem.size() as f32 / ast.file.len() as f32
+        //    ast.mem.size() as f32 / ast.file.len() as f32
-        );
+        //);
         let mut output = String::new();
         write!(output, "{ast}").unwrap();
 

lang/src/lexer.rs

@@ -72,7 +72,6 @@ macro_rules! gen_token_kind {
                 } + 1)
             }
 
-            #[inline(always)]
             fn from_ident(ident: &[u8]) -> Self {
                 match ident {
                     $($keyword_lit => Self::$keyword,)*
@@ -377,6 +376,25 @@ impl<'a> Lexer<'a> {
         Self::restore(input, 0)
     }
 
+    pub fn imports(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() }
     }
@@ -404,9 +422,9 @@ impl<'a> Lexer<'a> {
     }
 
     pub fn last(&mut self) -> Token {
-        let mut token = self.next();
+        let mut token = self.eat();
         loop {
-            let next = self.next();
+            let next = self.eat();
             if next.kind == TokenKind::Eof {
                 break;
             }
@@ -415,7 +433,7 @@ impl<'a> Lexer<'a> {
         token
     }
 
-    pub fn next(&mut self) -> Token {
+    pub fn eat(&mut self) -> Token {
         use TokenKind as T;
         loop {
             let mut start = self.pos;

lang/src/lib.rs

@@ -20,7 +20,8 @@
     iter_intersperse,
     str_from_raw_parts,
     ptr_sub_ptr,
-    slice_from_ptr_range
+    slice_from_ptr_range,
+    is_sorted
 )]
 #![warn(clippy::dbg_macro)]
 #![allow(stable_features, internal_features)]
@@ -36,7 +37,7 @@ use {
         ty::ArrayLen,
     },
     alloc::{collections::BTreeMap, string::String, vec::Vec},
-    core::{cell::Cell, fmt::Display, ops::Range},
+    core::{cell::Cell, ops::Range},
     hashbrown::hash_map,
     hbbytecode as instrs,
 };
@@ -68,7 +69,7 @@ pub mod parser;
 #[cfg(feature = "opts")]
 pub mod son;
 
-mod lexer;
+pub mod lexer;
 #[cfg(feature = "opts")]
 mod vc;
 
@@ -535,37 +536,54 @@ mod ty {
         fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             use Kind as TK;
             match TK::from_ty(self.ty) {
-                TK::Module(idx) => write!(f, "@use({:?})[{}]", self.files[idx as usize].path, idx),
+                TK::Module(idx) => {
-                TK::Builtin(ty) => write!(f, "{}", to_str(ty)),
+                    f.write_str("@use(\"")?;
-                TK::Ptr(ty) => {
+                    self.files[idx as usize].path.fmt(f)?;
-                    write!(f, "^{}", self.rety(self.tys.ins.ptrs[ty as usize].base))
+                    f.write_str(")[")?;
+                    idx.fmt(f)?;
+                    f.write_str("]")
                 }
+                TK::Builtin(ty) => f.write_str(to_str(ty)),
+                TK::Ptr(ty) => self.rety(self.tys.ins.ptrs[ty as usize].base).fmt(f),
                 TK::Struct(idx) => {
                     let record = &self.tys.ins.structs[idx as usize];
                     if ident::is_null(record.name) {
-                        write!(f, "[{idx}]{{")?;
+                        f.write_str("[")?;
+                        idx.fmt(f)?;
+                        f.write_str("]{")?;
                         for (i, &super::Field { name, ty }) in
                             self.tys.struct_fields(idx).iter().enumerate()
                         {
                             if i != 0 {
-                                write!(f, ", ")?;
+                                f.write_str(", ")?;
                             }
-                            write!(f, "{}: {}", self.tys.names.ident_str(name), self.rety(ty))?;
+                            f.write_str(self.tys.names.ident_str(name))?;
+                            f.write_str(": ")?;
+                            self.rety(ty).fmt(f)?;
                         }
-                        write!(f, "}}")
+                        f.write_str("}")
                     } else {
                         let file = &self.files[record.file as usize];
-                        write!(f, "{}", file.ident_str(record.name))
+                        f.write_str(file.ident_str(record.name))
                     }
                 }
-                TK::Func(idx) => write!(f, "fn{idx}"),
+                TK::Func(idx) => {
-                TK::Global(idx) => write!(f, "global{idx}"),
+                    f.write_str("fn")?;
+                    idx.fmt(f)
+                }
+                TK::Global(idx) => {
+                    f.write_str("global")?;
+                    idx.fmt(f)
+                }
                 TK::Slice(idx) => {
                     let array = self.tys.ins.arrays[idx as usize];
-                    match array.len {
+                    f.write_str("[")?;
-                        ArrayLen::MAX => write!(f, "[{}]", self.rety(array.ty)),
+                    self.rety(array.ty).fmt(f)?;
-                        len => write!(f, "[{}; {len}]", self.rety(array.ty)),
+                    if array.len != ArrayLen::MAX {
+                        f.write_str("; ")?;
+                        array.len.fmt(f)?;
                     }
+                    f.write_str("]")
                 }
             }
         }
@@ -911,6 +929,12 @@ impl Types {
         })
     }
 
+    fn reassemble(&mut self, buf: &mut Vec<u8>) {
+        self.ins.funcs.iter_mut().for_each(|f| f.offset = u32::MAX);
+        self.ins.globals.iter_mut().for_each(|g| g.offset = u32::MAX);
+        self.assemble(buf)
+    }
+
     fn assemble(&mut self, to: &mut Vec<u8>) {
         to.extend([0u8; HEADER_SIZE]);
 
@@ -1505,7 +1529,7 @@ impl hbvm::mem::Memory for LoggedMem {
 
 struct AsHex<'a>(&'a [u8]);
 
-impl Display for AsHex<'_> {
+impl core::fmt::Display for AsHex<'_> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         for &b in self.0 {
             write!(f, "{b:02x}")?;
@@ -1513,3 +1537,14 @@ impl Display for AsHex<'_> {
         Ok(())
     }
 }
+
+pub fn quad_sort<T>(mut slice: &mut [T], mut cmp: impl FnMut(&T, &T) -> core::cmp::Ordering) {
+    while let Some(it) = slice.take_first_mut() {
+        for ot in &mut *slice {
+            if cmp(it, ot) == core::cmp::Ordering::Greater {
+                core::mem::swap(it, ot);
+            }
+        }
+    }
+    debug_assert!(slice.is_sorted_by(|a, b| cmp(a, b) != core::cmp::Ordering::Greater));
+}

lang/src/parser.rs

@@ -85,7 +85,7 @@ impl<'a, 'b> Parser<'a, 'b> {
         let mut lexer = Lexer::new(input);
         Self {
             loader,
-            token: lexer.next(),
+            token: lexer.eat(),
             lexer,
             path,
             ctx,
@@ -111,7 +111,7 @@ impl<'a, 'b> Parser<'a, 'b> {
                         self.lexer.source(),
                         self.path,
                         ident::pos(id.ident),
-                        format_args!(
+                        &format_args!(
                             "undeclared identifier: {}",
                             self.lexer.slice(ident::range(id.ident))
                         ),
@@ -127,7 +127,7 @@ impl<'a, 'b> Parser<'a, 'b> {
     }
 
     fn next(&mut self) -> Token {
-        core::mem::replace(&mut self.token, self.lexer.next())
+        core::mem::replace(&mut self.token, self.lexer.eat())
     }
 
     fn ptr_expr(&mut self) -> &'a Expr<'a> {
@@ -328,16 +328,9 @@ impl<'a, 'b> Parser<'a, 'b> {
                 },
                 captured: {
                     self.ns_bound = prev_boundary;
-                    let mut captured = &mut self.ctx.captured[prev_captured..];
+                    let captured = &mut self.ctx.captured[prev_captured..];
-                    while let Some(it) = captured.take_first_mut() {
+                    crate::quad_sort(captured, core::cmp::Ord::cmp);
-                        for ot in &mut *captured {
+                    let preserved = captured.partition_dedup().0.len();
-                            if it > ot {
-                                core::mem::swap(it, ot);
-                            }
-                        }
-                    }
-                    debug_assert!(captured.is_sorted());
-                    let preserved = self.ctx.captured[prev_captured..].partition_dedup().0.len();
                     self.ctx.captured.truncate(prev_captured + preserved);
                     self.arena.alloc_slice(&self.ctx.captured[prev_captured..])
                 },
@@ -983,7 +976,7 @@ impl AstInner<[Symbol]> {
         let exprs =
             unsafe { core::mem::transmute(Parser::parse(ctx, &file, path, loader, &arena)) };
 
-        ctx.symbols.sort_unstable_by_key(|s| s.name);
+        crate::quad_sort(&mut ctx.symbols, |a, b| a.name.cmp(&b.name));
 
         let layout = Self::layout(ctx.symbols.len());
 
@@ -1012,22 +1005,6 @@ impl AstInner<[Symbol]> {
     }
 }
 
-fn report_to(file: &str, path: &str, pos: Pos, msg: impl fmt::Display, out: &mut impl fmt::Write) {
-    let (line, mut col) = lexer::line_col(file.as_bytes(), pos);
-    #[cfg(feature = "std")]
-    let disp = crate::fs::display_rel_path(path);
-    #[cfg(not(feature = "std"))]
-    let disp = path;
-    _ = writeln!(out, "{}:{}:{}: {}", disp, line, col, msg);
-
-    let line = &file[file[..pos as usize].rfind('\n').map_or(0, |i| i + 1)
-        ..file[pos as usize..].find('\n').unwrap_or(file.len()) + pos as usize];
-    col += line.matches('\t').count() * 3;
-
-    _ = writeln!(out, "{}", line.replace("\t", "    "));
-    _ = writeln!(out, "{}^", " ".repeat(col - 1));
-}
-
 pub struct Report<'a, D> {
     file: &'a str,
     path: &'a str,
@@ -1048,6 +1025,22 @@ impl<D: core::fmt::Display> core::fmt::Display for Report<'_, D> {
     }
 }
 
+fn report_to(file: &str, path: &str, pos: Pos, msg: &dyn fmt::Display, out: &mut impl fmt::Write) {
+    let (line, mut col) = lexer::line_col(file.as_bytes(), pos);
+    #[cfg(feature = "std")]
+    let disp = crate::fs::display_rel_path(path);
+    #[cfg(not(feature = "std"))]
+    let disp = path;
+    _ = writeln!(out, "{}:{}:{}: {}", disp, line, col, msg);
+
+    let line = &file[file[..pos as usize].rfind('\n').map_or(0, |i| i + 1)
+        ..file[pos as usize..].find('\n').map_or(file.len(), |i| i + pos as usize)];
+    col += line.matches('\t').count() * 3;
+
+    _ = writeln!(out, "{}", line.replace("\t", "    "));
+    _ = writeln!(out, "{}^", " ".repeat(col - 1));
+}
+
 #[derive(PartialEq, Eq, Hash)]
 pub struct Ast(NonNull<AstInner<[Symbol]>>);
 

vm/src/lib.rs

@@ -126,11 +126,33 @@ pub enum VmRunError {
 
     /// Invalid operand
     InvalidOperand,
-
-    /// Unimplemented feature
-    Unimplemented,
 }
 
+impl core::fmt::Display for VmRunError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            VmRunError::InvalidOpcode(op) => {
+                f.write_str("invalid op code: ").and_then(|_| op.fmt(f))
+            }
+            VmRunError::LoadAccessEx(address) => {
+                f.write_str("falied to load at ").and_then(|_| address.fmt(f))
+            }
+            VmRunError::ProgramFetchLoadEx(address) => {
+                f.write_str("falied to load instruction at ").and_then(|_| address.fmt(f))
+            }
+            VmRunError::StoreAccessEx(address) => {
+                f.write_str("falied to store at ").and_then(|_| address.fmt(f))
+            }
+            VmRunError::RegOutOfBounds => f.write_str("reg out of bounds"),
+            VmRunError::AddrOutOfBounds => f.write_str("addr out-of-bounds"),
+            VmRunError::Unreachable => f.write_str("unreachable"),
+            VmRunError::InvalidOperand => f.write_str("invalud operand"),
+        }
+    }
+}
+
+impl core::error::Error for VmRunError {}
+
 /// Virtual machine halt ok
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum VmRunOk {

xtask/src/main.rs

@@ -13,28 +13,47 @@ fn root() -> &'static Path {
     Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap()
 }
 
-fn exec(cmd: impl AsRef<str>) -> io::Result<()> {
+fn build_cmd(cmd: impl AsRef<str>) -> std::process::Command {
     let mut args = cmd.as_ref().split_whitespace();
     let mut c = std::process::Command::new(args.next().unwrap());
     for arg in args {
         c.arg(arg);
     }
-    if !c.status()?.success() {
+    c
-        return Err(io::Error::other(format!("command failed: {}", cmd.as_ref())));
+}
+
+fn exec(mut cmd: std::process::Command) -> io::Result<()> {
+    if !cmd.status()?.success() {
+        return Err(io::Error::other(format!("command failed: {:?}", cmd)));
     }
     Ok(())
 }
 
+fn build_wasm_blob(name: &str, debug: bool) -> io::Result<()> {
+    let mut c = build_cmd(if debug { "cargo wasm-build-debug" } else { "cargo wasm-build" });
+    c.arg(format!("wasm-{name}"));
+    exec(c)?;
+
+    let out_path = format!("target/wasm32-unknown-unknown/small/wasm_{name}.wasm");
+    if !debug {
+        exec(build_cmd(format!("wasm-opt -Oz {out_path} -o {out_path}")))?;
+    }
+    exec(build_cmd(format!("cp {out_path} depell/src/wasm-{name}.wasm")))
+}
+
 fn main() -> io::Result<()> {
     let args = std::env::args().skip(1).collect::<Vec<_>>();
     match args[0].as_str() {
         "fmt" => fmt(args[1] == "-r" || args[1] == "--renumber"),
         "build-depell" => {
-            exec(
+            build_wasm_blob("hbfmt", false)?;
-                "cargo build -p wasm-hbfmt --target wasm32-unknown-unknown \
+            build_wasm_blob("hbc", false)?;
-                --profile=small -Zbuild-std=core,alloc",
+            exec(build_cmd("cargo build -p depell --release"))?;
-            )?;
+            Ok(())
-            exec("cargo build -p depell --release")?;
+        }
+        "build-depell-debug" => {
+            build_wasm_blob("hbfmt", true)?;
+            build_wasm_blob("hbc", true)?;
             Ok(())
         }
         _ => Ok(()),