minor jank auto resolution detection

memory bug fixes
update hblang
update render examples
obliterate render_driver (not useful)

.cargo/config.toml

@@ -1,3 +1,3 @@
 [alias]
-repbuild = "run --manifest-path ./repbuild/Cargo.toml -- "
+repbuild = "run --manifest-path ./repbuild/Cargo.toml -r --"
 dev = "run --manifest-path ./dev/Cargo.toml -r --"

HELP.md

@@ -1,69 +0,0 @@
-### What are the requirements?
-- A machine with [Rustc Tier 1 platform support](https://doc.rust-lang.org/nightly/rustc/platform-support.html#tier-1-with-host-tools)
-- Rustup
-- QEMU (for executing)
-- GIT CLI
-
-### How do I run ableos?
-- It is recommended to run ableos under QEMU. Here is how:
-    - Install QEMU
-    - Clone ableos
-    - Go to ableos directory
-    - Pull the limine submodule with `git submodule update --init`
-    - Run `cargo repbuild help`
-
-### How can I contribute?
-- [Contribute code](#how-do-i-contribute-code)
-- [Run ableos on your machine](#how-do-i-run-ableos)
-- Find bugs
-- Create media showing ableos
-
-### How do I contribute code?
-- Start by forking ableos
-- Write something that runs in the userspace, for example:
-    - System drivers
-    - Programs
-    - Libraries
-- Patch bugs and improve code in the kernel
-- Ensure that the code is OK to be maintained by asking in the [discord](https://discord.gg/t5Wt3K4YNA)
-- When you have finished your changes, you can submit a pull request for review [here](https://git.ablecorp.us/ableos/ableos)
-
-### repbuild and kernel compile, but QEMU isn't starting
-- Ensure you have the `qemu-desktop-{arch}` for your OS and target architecture installed
-- Try running again with `--noaccel` if you have QEMU already
-
-### I have run using repbuild but it's slow
-- Ensure release mode is enabled with the `-r` flag
-- Remove the `--noaccel` flag if you can
-- If both of these are already done, there may be a problem with thee VM, kernel, your program, or the hblang compiler
-
-### Compiler is complaining about "reg id leaked"
-- [Submit](#how-do-i-report-a-compiler-bug) an issue, reg id leaked is a bug
-
-### My program isn't running
-- Refer to [here](#i-have-run-using-repbuild-but-its-slow), it may be that your program is simply starting slowly
-- Ensure that your program has a properly written meta.toml file
-- Ensure that your program is enabled in [system_config.toml](sysdata/system_config.toml)
-- Try running again with `--noaccel`, there is a known bug with some systems that prevents programs from starting.
-
-### Kernel panic??? Huh???
-- Kernel panics can be caused by improperly using memory (e.g, writing out of bounds)
-- Kernel panics are most likely to be caused when accessing memory or using `@eca` for kernel ecalls
-- [Report](#how-do-i-report-an-ableos-bug) a kernel panic
-
-### I am running in release mode but I have no debug info
-- Add the `-d` flag for debug info
-
-### What is `@eca`? How do I use it?
-- Eca is an ecall. They are similar to syscalls
-- The `@eca` directive takes the following arguments:
-    - `@eca(ecall_number, reg_1, ..., reg_n)`
-- The various ecalls have different arguments that are given by register values
-- Most ecalls are wrapped by `stn`, for example, `random`, `buffer`, and `memory` all make use of ecalls
-- All ecalls can be found [ecah.rs](kernel/src/holeybytes/ecah.rs)
-
-### How do I report an ableos bug?
-- Submit an issue [here](https://git.ablecorp.us/ableos/ableos/issues) or report it in the [discord](https://discord.gg/t5Wt3K4YNA)
-
-### How do I report a compiler bug?
-- Submit an issue [here](https://git.ablecorp.us/ableos/holey-bytes/issues) or report it in the [discord](https://discord.gg/t5Wt3K4YNA)

README.md

@@ -10,7 +10,15 @@ Donations can be made [here on Liberapay](https://liberapay.com/AbleTheAbove) or
 <img src="https://img.shields.io/liberapay/patrons/AbleTheAbove.svg?logo=liberapay">
 
 # Compiling
-See [HELP.md](HELP.md)
+AbleOS should be able to be built on any platform which is supported by
+[Rustc Tier 1 platform support](https://doc.rust-lang.org/nightly/rustc/platform-support.html#tier-1-with-host-tools).
+
+For running AbleOS, `repbuild` uses QEMU.
+
+## Steps
+1. Ensure you have qemu installed
+2. `git submodule update --init`
+3. `cargo repbuild run`
 
 # Developing
-There is a new work in progress developer tool for hblang. (see: dev folder)
+There is a new work in progress developer tool for hblang. 

dev/src/idl/mod.rs

@@ -1,84 +1,20 @@
-pub mod protocol;
+use logos::Logos;
 
-use std::io::Read;
-
-use {
-    logos::{Lexer, Logos},
-    protocol::Protocol,
-};
-
-#[derive(Logos, Debug, PartialEq, Clone)]
+#[derive(Logos, Debug, PartialEq)]
 #[logos(skip r"[ \t\n\f]+")] // Ignore this regex pattern between tokens
 enum Token {
     // Tokens can be literal strings, of any length.
     #[token("protocol")]
     Protocol,
 
-    #[token("{")]
-    LBrace,
+    #[token(".")]
+    Period,
 
-    #[token("}")]
-    RBrace,
-
-    #[token("(")]
-    LParen,
-
-    #[token(")")]
-    RParen,
-
-    #[token(":")]
-    Colon,
-    #[token(";")]
-    SemiColon,
-
-    #[token(",")]
-    Comma,
-
-    #[token("=")]
-    Equal,
-
-    #[token("->")]
-    RArrow,
-
-    #[regex("[a-zA-Z_]+", |lex|{lex.slice().to_string()})]
-    Text(String),
-
-    #[regex("[1234567890]+", |lex|{lex.slice().parse::<u64>().unwrap()})]
-    Number(u64),
-
-    #[regex(r"@[a-zA-Z_]+", |lex|{lex.slice().to_string()})]
-    Decorator(String),
-
-    #[regex(r#"@[a-zA-Z_]+\([a-zA-Z,0-9=]+\)"#, |lex|{lex.slice().to_string()})]
-    DecoratorOption(String),
+    // Or regular expressions.
+    #[regex("[a-zA-Z]+")]
+    Text,
 }
 
-pub fn build_idl(name: String) {
-    let contents = open_protocol(name);
-    let lex = Token::lexer(&contents);
-    let mut tokens = vec![];
-    for x in lex {
-        match x {
-            Ok(token) => {
-                println!("{:?}", token);
-                tokens.push(token);
-            }
-            Err(err) => println!("{:?}", err),
-        }
-    }
-    build(tokens);
-}
-
-fn build(a: Vec<Token>) {
-    for toke in a {
-        println!("{:?}", toke);
-    }
-}
-
-fn open_protocol(name: String) -> String {
-    let path = format!("sysdata/idl/{}/src/protocol.aidl", name);
-    let mut file = std::fs::File::open(path).unwrap();
-    let mut contents = String::new();
-    file.read_to_string(&mut contents).unwrap();
-    contents
+pub fn main() {
+    let mut lex = Token::lexer("Create ridiculously fast Lexers.");
 }

dev/src/idl/protocol.rs

@@ -1,17 +0,0 @@
-pub enum ProtocolTypes {
-    Byte,
-}
-
-pub struct Protocol {}
-impl Protocol {
-    pub fn is_empty(&self) -> bool {
-        true
-    }
-
-    pub fn validate_data(&self, data: Vec<u8>) -> bool {
-        if !data.is_empty() && self.is_empty() {
-            return false;
-        }
-        true
-    }
-}

dev/src/main.rs

@@ -1,6 +1,4 @@
 use std::io::Write;
-
-use idl::build_idl;
 pub mod idl;
 
 pub enum Options {
@@ -9,7 +7,7 @@ pub enum Options {
     New,
     Run,
 }
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq)]
 pub enum DevelopmentType {
     Program,
     Library,
@@ -26,7 +24,7 @@ fn main() {
 
     match subcommand {
         "build" => {
-            let name = &args.pop().unwrap();
+            let name = &args[1];
             build(name.to_string())
         }
         "new" => {
@@ -72,27 +70,6 @@ pub fn new(development_type: DevelopmentType, name: String) {
     let readme_contents = format!("# {}", name);
     readme_file.write_all(readme_contents.as_bytes()).unwrap();
 
-    let contents = format!(
-        "[package]
-name = \"{}\"
-authors = [\"\"]
-
-[dependants.libraries]
-
-[dependants.binaries]
-hblang.version = \"1.0.0\"
-
-[build]
-command = \"hblang src/main.hb\"
-",
-        name
-    );
-
-    let toml_path_string = format!("{}/meta.toml", project_folder_path_string);
-    let mut readme_file = std::fs::File::create(toml_path_string.clone()).unwrap();
-
-    readme_file.write_all(contents.as_bytes()).unwrap();
-
     let src_folder_path_string = format!("{}/src", project_folder_path_string);
     std::fs::create_dir(src_folder_path_string.clone()).unwrap();
 
@@ -126,21 +103,8 @@ fn run() {
 
 fn build(name: String) {
     println!("building {}", name);
-    let mut a = name.split("/");
-    let dev_type = a.next().unwrap();
-    let name = a.next().unwrap().to_string();
-    match dev_type {
-        "programs" => build_program(name),
-        "idl" => build_idl(name),
-        _ => {
-            panic!()
-        }
-    }
 }
 
-pub fn build_program(_name: String) {}
-pub fn build_library(_name: String) {}
-
 fn help() {
     println!(
         "==========

kernel/.cargo/config.toml

@@ -4,3 +4,6 @@ build-std-features = ["compiler-builtins-mem"]
 
 [build]
 target = "./targets/x86_64-ableos.json"
+
+[target.'cfg(target_arch = "x86_64")']
+rustflags = ["-C", "target-feature=+rdrand"]

kernel/Cargo.toml

@@ -5,10 +5,8 @@ version = "0.2.0"
 
 
 [dependencies]
-# embedded-graphics = "0.8"
-hbvm = { git = "https://git.ablecorp.us/AbleOS/holey-bytes.git", features = [
-	"nightly",
-] }
+embedded-graphics = "0.8"
+hbvm.git = "https://git.ablecorp.us/ableos/holey-bytes"
 log = "0.4"
 spin = "0.9"
 slab = { version = "0.4", default-features = false }
@@ -16,35 +14,42 @@ uart_16550 = { version = "0.3", features = ["nightly"] }
 xml.git = "https://git.ablecorp.us/ableos/ableos_userland"
 versioning.git = "https://git.ablecorp.us/ableos/ableos_userland"
 # able_graphics_library.git = "https://git.ablecorp.us/ableos/ableos_userland"
-hashbrown = { version = "0.15", features = ["nightly"] }
-limine = "0.1"
+hashbrown = { version = "0.14", features = ["nightly"] }
+
+[dependencies.limine]
+version = "0.1"
+#git = "https://github.com/limine-bootloader/limine-rs"
 
 [dependencies.crossbeam-queue]
 version = "0.3"
 default-features = false
 features = ["alloc", "nightly"]
 
+# [dependencies.clparse]
+# git = "https://git.ablecorp.us/ableos/ableos_userland"
+# default-features = false
+
 [dependencies.derive_more]
 version = "1"
 default-features = false
 features = [
-	"add",
-	"add_assign",
-	"constructor",
-	"display",
-	"from",
-	"into",
-	"mul",
-	"mul_assign",
-	"not",
-	"sum",
+    "add",
+    "add_assign",
+    "constructor",
+    "display",
+    "from",
+    "into",
+    "mul",
+    "mul_assign",
+    "not",
+    "sum",
 ]
 
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
 x86_64 = "0.15"
 x2apic = "0.4"
-# virtio-drivers = "0.7"
+virtio-drivers = "0.7"
 
 [target.'cfg(target_arch = "riscv64")'.dependencies]
 sbi = "0.2.0"

kernel/lds/x86_64.ld

@@ -38,7 +38,6 @@ SECTIONS
 
     .data : {
         *(.data .data.*)
-        *(.got .got.*)
     } :data
 
     .bss : {

kernel/src/arch/aarch64/device_info_collector.rs

@@ -1,5 +1,6 @@
 use {
-    crate::{device_tree::DeviceTree, kmain::DEVICE_TREE},
+    crate::{alloc::string::ToString, device_tree::DeviceTree, kmain::DEVICE_TREE},
+    alloc::string::String,
     core::arch::asm,
     xml::XMLElement,
 };
@@ -27,7 +28,7 @@ fn collect_cpu_info(device_tree: &mut DeviceTree) {
     cpus.push(cpu);
 }
 
-fn cpu_id<'a>() -> (&'a str, u64) {
+fn cpu_id() -> (String, u64) {
     let mut cpu_id: u64;
     unsafe {
         asm!("mrs {cpu_id}, MIDR_EL1",
@@ -38,11 +39,11 @@ fn cpu_id<'a>() -> (&'a str, u64) {
     let cpu_name = match cpu_id {
         // the source of these two was a stackoverflow question
         // https://raspberrypi.stackexchange.com/questions/117175/how-do-i-read-the-cpuid-in-aarch64-asm
-        0x410FD034 => "Cortex-A53",
-        0x410FD083 => "Cortex-A72",
+        0x410FD034 => "Cortex-A53".to_string(),
+        0x410FD083 => "Cortex-A72".to_string(),
         // the source of this one was checking the cpu id :thinking:
-        0x410FD493 => "Neoverse N2",
-        _ => "Unknown",
+        0x410FD493 => "Neoverse N2".to_string(),
+        _ => "Unknown".to_string(),
     };
     log::trace!("CPU Name: {cpu_name} - CPU ID: 0x{:X}", cpu_id);
 

kernel/src/arch/aarch64/logging.rs

@@ -1,9 +1,9 @@
 use {crate::logger::TERMINAL_LOGGER, core::fmt::Write, spin::Mutex};
-pub static SERIAL_CONSOLE: Mutex<SerialConsole> = Mutex::new(SerialConsole {
+static SERIAL_CONSOLE: Mutex<SerialConsole> = Mutex::new(SerialConsole {
     uart: 0x09000000 as *mut u8,
 });
 
-pub struct SerialConsole {
+struct SerialConsole {
     uart: *mut u8,
 }
 
@@ -22,7 +22,7 @@ unsafe impl Send for SerialConsole {}
 
 pub fn log(args: core::fmt::Arguments<'_>) -> core::fmt::Result {
     SERIAL_CONSOLE.lock().write_fmt(args)?;
-    // TERMINAL_LOGGER.lock().write_fmt(args)?;
+    TERMINAL_LOGGER.lock().write_fmt(args)?;
 
     Ok(())
 }

kernel/src/arch/mod.rs

@@ -14,29 +14,3 @@ arch_cond!(
     riscv64: "riscv64",
     x86_64: "x86_64",
 );
-
-#[cfg(target_arch = "x86_64")]
-use {crate::arch::interrupts::Interrupt, alloc::string::String};
-#[cfg(target_arch = "x86_64")]
-pub struct InterruptList {
-    list: HashMap<Interrupt, String>,
-}
-#[cfg(target_arch = "x86_64")]
-use hashbrown::HashMap;
-#[cfg(target_arch = "x86_64")]
-impl InterruptList {
-    pub fn new() -> Self {
-        Self {
-            list: HashMap::new(),
-        }
-    }
-}
-#[cfg(target_arch = "x86_64")]
-use spin::{Lazy, Mutex};
-#[cfg(target_arch = "x86_64")]
-pub static INTERRUPT_LIST: Lazy<Mutex<InterruptList>> = Lazy::new(|| {
-    let mut il = InterruptList::new();
-    use crate::alloc::string::ToString;
-    il.list.insert(Interrupt::Timer, "PS/2 Mouse".to_string());
-    Mutex::new(il)
-});

kernel/src/arch/x86_64/gdt.rs

@@ -12,7 +12,7 @@ use {
 pub const DOUBLE_FAULT_IX: u16 = 0;
 
 const STACK_SIZE: usize = 5 * 1024;
-const STACK_ALIGNMENT: usize = 1;
+const STACK_ALIGNMENT: usize = 4096;
 
 pub unsafe fn init() {
     use x86_64::instructions::{
@@ -39,7 +39,7 @@ static TSS: Lazy<TaskStateSegment> = Lazy::new(|| {
     let stack_ptr = unsafe {
         let layout = alloc::alloc::Layout::from_size_align(STACK_SIZE, STACK_ALIGNMENT)
             .expect("Failed to create stack layout");
-        let stack = alloc::alloc::alloc(layout);
+        let stack = alloc::alloc::alloc_zeroed(layout);
         VirtAddr::from_ptr(stack) + STACK_SIZE as u64
     };
 

kernel/src/arch/x86_64/interrupts.rs

@@ -1,54 +1,56 @@
+// TODO: Turn apic keyboard interrupt into a standard ipc message
 use {
-    core::mem::MaybeUninit,
     log::trace,
+    spin::{Lazy, Mutex},
     x2apic::lapic::{LocalApic, LocalApicBuilder},
     x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode},
 };
 
-/// Safety: Using LAPIC or IDT before init() is UB
-/// Using
-static mut LAPIC: LocalApic = unsafe { MaybeUninit::zeroed().assume_init() };
-static mut IDT: InterruptDescriptorTable = unsafe { MaybeUninit::zeroed().assume_init() };
+pub unsafe fn init() {
+    trace!("Initialising IDT");
+    IDT.load();
+    Lazy::force(&LAPIC);
+    x86_64::instructions::interrupts::enable();
+}
 
 #[repr(u8)]
-#[derive(Debug, Eq, Hash, PartialEq)]
-
-pub enum Interrupt {
+enum Interrupt {
     Timer = 32,
+
     ApicErr = u8::MAX - 1,
     Spurious = u8::MAX,
 }
 
-pub unsafe fn init() {
-    trace!("Initializing IDT and LAPIC");
-
-    // Initialize and load the IDT
-    IDT = InterruptDescriptorTable::new();
-    IDT.double_fault
-        .set_handler_fn(double_fault)
-        .set_stack_index(super::gdt::DOUBLE_FAULT_IX);
-    IDT.page_fault.set_handler_fn(page_fault);
-
-    IDT[Interrupt::ApicErr as u8].set_handler_fn(apic_err);
-    IDT[Interrupt::Spurious as u8].set_handler_fn(spurious);
-    IDT[Interrupt::Timer as u8].set_handler_fn(timer);
-
-    IDT.load();
-
-    LAPIC = LocalApicBuilder::new()
+pub(crate) static LAPIC: Lazy<Mutex<LocalApic>> = Lazy::new(|| {
+    let mut lapic = LocalApicBuilder::new()
         .timer_vector(Interrupt::Timer as usize)
         .error_vector(Interrupt::ApicErr as usize)
         .spurious_vector(Interrupt::Spurious as usize)
         .set_xapic_base(
-            x2apic::lapic::xapic_base()
+            unsafe { x2apic::lapic::xapic_base() }
                 + super::memory::HHDM_OFFSET.load(core::sync::atomic::Ordering::Relaxed),
         )
         .build()
-        .expect("Failed to setup Local APIC");
-    LAPIC.enable();
+        .expect("failed to setup Local APIC");
+    unsafe { lapic.enable() };
+    Mutex::new(lapic)
+});
 
-    x86_64::instructions::interrupts::enable();
-}
+static IDT: Lazy<InterruptDescriptorTable> = Lazy::new(|| {
+    let mut idt = InterruptDescriptorTable::new();
+    unsafe {
+        idt.double_fault
+            .set_handler_fn(double_fault)
+            .set_stack_index(super::gdt::DOUBLE_FAULT_IX);
+    }
+    idt.page_fault.set_handler_fn(page_fault);
+
+    idt[Interrupt::ApicErr as u8].set_handler_fn(apic_err);
+    idt[Interrupt::Spurious as u8].set_handler_fn(spurious);
+    idt[Interrupt::Timer as u8].set_handler_fn(timer);
+
+    idt
+});
 
 extern "x86-interrupt" fn double_fault(stack_frame: InterruptStackFrame, error_code: u64) -> ! {
     panic!("Double fault: error code {error_code} \n{stack_frame:#?}")
@@ -62,49 +64,13 @@ extern "x86-interrupt" fn page_fault(
 }
 
 extern "x86-interrupt" fn timer(_isf: InterruptStackFrame) {
-    // interrupt(Interrupt::Timer);
-
-    unsafe {
-        LAPIC.end_of_interrupt();
-    }
+    unsafe { LAPIC.lock().end_of_interrupt() };
 }
 
 extern "x86-interrupt" fn apic_err(_: InterruptStackFrame) {
-    interrupt(Interrupt::ApicErr);
-
     panic!("Internal APIC error");
 }
 
 extern "x86-interrupt" fn spurious(_: InterruptStackFrame) {
-    interrupt(Interrupt::Spurious);
-
-    unsafe {
-        LAPIC.end_of_interrupt();
-    }
-}
-
-fn interrupt(interrupt_type: Interrupt) {
-    use crate::arch::INTERRUPT_LIST;
-    let il = INTERRUPT_LIST.lock();
-    let val = il.list.get(&interrupt_type).unwrap();
-
-    use crate::holeybytes::kernel_services::service_definition_service::sds_search_service;
-    let buffer = sds_search_service(val);
-    if buffer != 0 {
-        use {crate::kmain::IPC_BUFFERS, alloc::vec::Vec};
-        let mut buffs = IPC_BUFFERS.lock();
-        match buffs.get_mut(&buffer) {
-            Some(buff) => {
-                let mut msg_vec = Vec::new();
-                msg_vec.push(0xFF);
-                buff.push(msg_vec.to_vec());
-                log::debug!("Sent Message {:?} to Buffer({})", msg_vec, buffer);
-            }
-            None => {
-                log::error!("Access of non-existent buffer {}", buffer)
-            }
-        }
-
-        // log::info!("{}", buffer);
-    }
+    unsafe { LAPIC.lock().end_of_interrupt() };
 }

kernel/src/arch/x86_64/mod.rs

@@ -10,7 +10,7 @@ pub mod graphics;
 pub(crate) mod interrupts;
 pub mod logging;
 pub mod pci;
-// pub mod virtio;
+pub mod virtio;
 
 pub use {logging::log, memory::PAGE_SIZE};
 
@@ -30,11 +30,9 @@ const INITIAL_KERNEL_HEAP_SIZE: *const () = _initial_kernel_heap_size as _;
 
 #[no_mangle]
 #[naked]
-#[cfg(not(target_feature = "avx2"))]
 unsafe extern "C" fn _kernel_start() -> ! {
-    // Initialise SSE, then jump to kernel entrypoint
-    core::arch::naked_asm!(
-        // Initialise SSE
+    // Initialise SSE and jump to kernel entrypoint
+    core::arch::asm!(
         "mov rax, cr0",
         "and ax, 0xfffb",
         "or ax, 0x2",
@@ -42,74 +40,16 @@ unsafe extern "C" fn _kernel_start() -> ! {
         "mov rax, cr4",
         "or ax, 3 << 9",
         "mov cr4, rax",
-
-        // Jump to the kernel entry point
         "jmp {}",
         sym start,
+        options(noreturn),
     )
 }
 
-#[no_mangle]
-#[naked]
-#[cfg(target_feature = "avx2")]
-unsafe extern "C" fn _kernel_start() -> ! {
-    core::arch::naked_asm!(
-        // Enable protected mode and configure control registers
-        "mov rax, cr0",
-        "and ax, 0xFFFB",  // Clear CR0.EM (bit 2) for coprocessor emulation
-        "or ax, 0x2",      // Set CR0.MP (bit 1) for coprocessor monitoring
-        "mov cr0, rax",
-
-        "mov rax, cr4",
-        "or ax, (1 << 9) | (1 << 10)", // Set CR4.OSFXSR (bit 9) and CR4.OSXMMEXCPT (bit 10)
-        "mov cr4, rax",
-
-        // Enable OSXSAVE (required for AVX, AVX2, and XSAVE)
-        "mov rax, cr4",
-        "or eax, 1 << 18", // Set CR4.OSXSAVE (bit 18)
-        "mov cr4, rax",
-
-        // Enable AVX and AVX2 state saving
-        "xor rcx, rcx",
-        "xgetbv",
-        "or eax, 7",       // Enable SSE, AVX, and AVX2 state saving
-        "xsetbv",
-
-        // Check for AVX and XSAVE support
-        "mov eax, 1",
-        "cpuid",
-        "and ecx, 0x18000000",
-        "cmp ecx, 0x18000000",
-        "jne {1}",          // Jump if AVX/OSXSAVE is not supported
-
-        // Check for BMI2 and AVX2 support
-        "mov eax, 7",
-        "xor ecx, ecx",
-        "cpuid",
-        "and ebx, (1 << 8) | (1 << 5)", // Check BMI2 (bit 8) and AVX2 (bit 5)
-        "cmp ebx, (1 << 8) | (1 << 5)", // Compare to ensure both are supported
-
-        // Check for LZCNT and POPCNT support
-        "mov eax, 1",
-        "cpuid",
-        "and ecx, (1 << 5) | (1 << 23)", // Check LZCNT (bit 5) and POPCNT (bit 23)
-        "cmp ecx, (1 << 5) | (1 << 23)", // Compare to ensure both are supported
-
-        // Jump to the kernel entry point
-        "jmp {0}",
-        sym start,
-        sym oops,
-    )
-}
-
-unsafe extern "C" fn oops() -> ! {
-    panic!("your cpu is ancient >:(")
-}
-
 unsafe extern "C" fn start() -> ! {
     logging::init();
     crate::logger::init().expect("failed to set logger");
-    log::debug!("Initialising AKern {}", crate::VERSION);
+    log::info!("Initialising AKern {}", crate::VERSION);
 
     static HDHM_REQ: HhdmRequest = HhdmRequest::new(0);
     memory::init_pt(VirtAddr::new(
@@ -188,7 +128,7 @@ unsafe extern "C" fn start() -> ! {
     // TODO: Add in rdseed and rdrand as sources for randomness
     let _rand = xml::XMLElement::new("Random");
 
-    log::debug!("Getting boot modules");
+    log::trace!("Getting boot modules");
     let bm = MOD_REQ.get_response().get();
 
     let mut bootmodules = alloc::vec::Vec::new();
@@ -226,7 +166,7 @@ unsafe extern "C" fn start() -> ! {
                 break;
             }
         }
-        log::debug!("Boot module count: {:?}", bootmodules.len());
+        log::info!("Boot module count: {:?}", bootmodules.len());
         assert_eq!(bm.module_count, bootmodules.len() as u64);
     }
 
@@ -249,7 +189,6 @@ unsafe extern "C" fn start() -> ! {
 /// Spin loop
 pub fn spin_loop() -> ! {
     loop {
-        core::hint::spin_loop();
         x86_64::instructions::hlt()
     }
 }

kernel/src/arch/x86_64/pci/mod.rs

@@ -8,12 +8,13 @@ pub struct PciDeviceInfo {
     pub full_class: PciFullClass,
     pub rev_id: u8,
 }
+use crate::alloc::string::ToString;
 
 /// Enumerate PCI devices and run initialisation routines on ones we support
 pub fn init(device_tree: &mut DeviceTree) {
     device_tree
         .devices
-        .insert("Unidentified PCI", alloc::vec![]);
+        .insert("Unidentified PCI".to_string(), alloc::vec![]);
     let mut devices = alloc::vec![];
 
     for bus in 0..=255 {
@@ -46,8 +47,7 @@ pub fn init(device_tree: &mut DeviceTree) {
                 pci_info.set_attribute("id", id);
                 pci_info.set_attribute("device", device_info.device);
                 pci_info.set_attribute("vendor", vendor);
-                pci_info.set_attribute("bus", bus);
-                pci_info.set_attribute("class", device_info.full_class);
+                pci_info.set_attribute("class", device_info.full_class.to_string());
                 dev.set_child(pci_info);
                 devices.push((dev_type, dev));
             }
@@ -68,8 +68,7 @@ pub fn check_device(bus: u8, device: u8) -> Option<PciDeviceInfo> {
         return None;
     }
 
-    let (reg2, addr) = unsafe { pci_config_read_2(bus, device, 0, 0x8) };
-    log::debug!("pci device-({}) addr {} is {}", device, addr, reg2);
+    let reg2 = unsafe { pci_config_read(bus, device, 0, 0x8) };
     let class = ((reg2 >> 16) & 0x0000_FFFF) as u16;
     let pci_class = PciFullClass::from_u16(class);
     let header_type = get_header_type(bus, device, 0);
@@ -460,7 +459,9 @@ unsafe fn pci_config_read(bus: u8, device: u8, func: u8, offset: u8) -> u32 {
     let func = func as u32;
     let offset = offset as u32;
     // construct address param
-    let address = (bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000;
+    let address =
+        ((bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000) as u32;
+
     // write address
     Port::new(0xCF8).write(address);
 
@@ -468,20 +469,6 @@ unsafe fn pci_config_read(bus: u8, device: u8, func: u8, offset: u8) -> u32 {
     Port::new(0xCFC).read()
 }
 
-unsafe fn pci_config_read_2(bus: u8, device: u8, func: u8, offset: u8) -> (u32, u32) {
-    let bus = bus as u32;
-    let device = device as u32;
-    let func = func as u32;
-    let offset = offset as u32;
-    // construct address param
-    let address = (bus << 16) | (device << 11) | (func << 8) | (offset & 0xFC) | 0x8000_0000;
-    // write address
-    Port::new(0xCF8).write(address);
-
-    // read data
-    (Port::new(0xCFC).read(), address)
-}
-
 unsafe fn pci_config_write(bus: u8, device: u8, func: u8, offset: u8, value: u32) {
     let bus = bus as u32;
     let device = device as u32;

kernel/src/arch/x86_64/virtio/mod.rs

@@ -1,5 +1,5 @@
 use {
-    core::ptr::NonNull,
+    core::{ptr::NonNull},
     virtio_drivers::{BufferDirection, Hal, PhysAddr},
 };
 

kernel/src/device_tree.rs

@@ -1,7 +1,11 @@
 //! A tree of hardware devices
 
-use {alloc::vec::Vec, core::fmt, hashbrown::HashMap};
-
+use {
+    crate::alloc::string::ToString,
+    alloc::{string::String, vec::Vec},
+    core::fmt,
+    hashbrown::HashMap,
+};
 /// A device object.
 /// TODO define device
 pub type Device = xml::XMLElement;
@@ -9,40 +13,38 @@ pub type Device = xml::XMLElement;
 /// A tree of devices
 // TODO: alphabetize this list
 #[derive(Debug)]
-pub struct DeviceTree<'a> {
+pub struct DeviceTree {
     /// The device tree
-    pub devices: HashMap<&'a str, Vec<Device>>,
+    pub devices: HashMap<String, Vec<Device>>,
 }
-impl<'a> DeviceTree<'a> {
+impl DeviceTree {
     /// Build the device tree. Does not populate the device tree
     pub fn new() -> Self {
         let mut dt = Self {
             devices: HashMap::new(),
         };
-        device_tree!(
-            dt,
-            [
-                "Mice",
-                "Keyboards",
-                "Controllers",
-                "Generic HIDs",
-                "Disk Drives",
-                "CD Drives",
-                "Batteries",
-                "Monitors",
-                "GPUs",
-                "CPUs",
-                "USB",
-                "Serial Ports",
-                "Cameras",
-                "Biometric Devices",
-            ]
-        );
+        device_tree!(dt, [
+            "Mice",
+            "Keyboards",
+            "Controllers",
+            "Generic HIDs",
+            "Disk Drives",
+            "CD Drives",
+            "Batteries",
+            "Monitors",
+            "GPUs",
+            "CPUs",
+            "USB",
+            "Serial Ports",
+            "Cameras",
+            "Biometric Devices",
+        ]);
         dt
     }
 }
-use crate::{device_tree, tab, utils::TAB};
-impl<'a> fmt::Display for DeviceTree<'a> {
+use crate::{utils::TAB, device_tree};
+use crate::tab;
+impl fmt::Display for DeviceTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f)?;
         for (device_type, devices) in &self.devices {

kernel/src/exe_format.rs

@@ -1,35 +0,0 @@
-enum Sections {
-    Header,
-    Code,
-    Data,
-    Debug,
-    Config,
-    Metadata,
-}
-
-// 64 byte header
-#[repr(packed)]
-struct AbleOsExecutableHeader {
-    magic_number: [u8; 3],
-    executable_version: u32,
-
-    code_length:     u64,
-    data_length:     u64,
-    debug_length:    u64,
-    config_length:   u64,
-    metadata_length: u64,
-}
-
-impl AbleOsExecutableHeader {
-    fn new() -> Self {
-        Self {
-            magic_number: [0x15, 0x91, 0xD2],
-            executable_version: 0,
-            code_length: 0,
-            config_length: 0,
-            data_length: 0,
-            debug_length: 0,
-            metadata_length: 0,
-        }
-    }
-}

kernel/src/holeybytes/ecah.rs

@@ -1,41 +1,19 @@
 //! Environment call handling routines
 
-use {alloc::boxed::Box, core::cell::LazyCell, hbvm::mem::Address};
-
-use crate::{
-    holeybytes::{
-        kernel_services::{
-            block_read, dt_msg_handler::dt_msg_handler, logging_service::log_msg_handler,
-            service_definition_service::sds_msg_handler,
-        },
-        ExecThread,
-    },
-    kmain::EXECUTOR,
-    task::Executor,
-};
+use crate::holeybytes::kernel_services::{block_read, service_definition_service::sds_msg_handler};
 
 use {
     super::Vm,
     crate::{arch, ipc::buffer::IpcBuffer, kmain::IPC_BUFFERS},
-    hbvm::value::Value,
-    log::{debug, error, info, trace},
+    log::{debug, error, info, trace, warn},
 };
 
-#[cfg(target_arch = "x86_64")]
-#[inline(always)]
-unsafe fn x86_out<T: x86_64::instructions::port::PortWrite>(address: u16, value: T) {
-    x86_64::instructions::port::Port::new(address).write(value);
-}
-#[cfg(target_arch = "x86_64")]
-#[inline(always)]
-unsafe fn x86_in<T: x86_64::instructions::port::PortRead>(address: u16) -> T {
-    x86_64::instructions::port::Port::new(address).read()
-}
-
-#[inline(always)]
 pub fn handler(vm: &mut Vm) {
     let ecall_number = vm.registers[2].cast::<u64>();
 
+    // debug!("Ecall number {:?}", ecall_number);
+    //info!("Register dump: {:?}", vm.registers);
+
     match ecall_number {
         0 => {
             // TODO: explode computer
@@ -47,9 +25,9 @@ pub fn handler(vm: &mut Vm) {
         1 => {
             // Make buffer
 
-            let bounded = match vm.registers[3] {
-                Value(0) => false,
-                Value(1) => true,
+            let bounded = match vm.registers[3].cast::<u64>() {
+                0 => false,
+                1 => true,
                 _ => {
                     panic!("Bad");
                 }
@@ -58,19 +36,22 @@ pub fn handler(vm: &mut Vm) {
             let length = vm.registers[4].cast::<u64>();
 
             let mut buffs = IPC_BUFFERS.lock();
+            let abc;
 
+            match bounded {
+                false => {
+                    abc = IpcBuffer::new(false, 0);
+                }
+                true => {
+                    abc = IpcBuffer::new(true, length);
+                }
+            };
             let buff_id = arch::hardware_random_u64();
-            buffs.insert(
-                buff_id,
-                match bounded {
-                    false => IpcBuffer::new(false, 0),
-                    true => IpcBuffer::new(true, length),
-                },
-            );
+            buffs.insert(buff_id, abc);
+            info!("Buffer ID: {}", buff_id);
             vm.registers[1] = hbvm::value::Value(buff_id);
         }
         2 => {
-            log::error!("Oops, deleting buffers is not implemented.")
             // Delete buffer
         }
         3 => {
@@ -79,6 +60,7 @@ pub fn handler(vm: &mut Vm) {
             let mem_addr = vm.registers[4].cast::<u64>();
             let length = vm.registers[5].cast::<u64>() as usize;
             trace!("IPC address: {:?}", mem_addr);
+            use alloc::vec::Vec;
 
             match buffer_id {
                 0 => match sds_msg_handler(vm, mem_addr, length) {
@@ -96,139 +78,174 @@ pub fn handler(vm: &mut Vm) {
                         Err(_) => {}
                     }
                 }
+                #[cfg(not(target_arch = "x86_64"))]
+                3 => info!("TODO: implement whatever buffer 3 does for no x86_64"),
                 #[cfg(target_arch = "x86_64")]
                 3 => {
+                    unsafe fn x86_out<T: x86_64::instructions::port::PortWrite>(
+                        address: u16,
+                        value: T,
+                    ) {
+                        x86_64::instructions::port::Port::new(address).write(value);
+                    }
+                    unsafe fn x86_in<T: x86_64::instructions::port::PortRead>(address: u16) -> T {
+                        x86_64::instructions::port::Port::new(address).read()
+                    }
                     let msg_vec = block_read(mem_addr, length);
                     let msg_type = msg_vec[0];
                     match msg_type {
-                        0 => unsafe {
-                            let size = msg_vec[1];
-                            let addr =
-                                u16::from_le_bytes(msg_vec[2..4].try_into().unwrap_unchecked());
-                            let value = match size {
-                                0 => x86_in::<u8>(addr) as u64,
-                                1 => x86_in::<u16>(addr) as u64,
-                                2 => x86_in::<u32>(addr) as u64,
-                                _ => panic!("Trying to read size other than: 8, 16, 32 from port."),
+                        0 => 'wow: {
+                            let size = match msg_vec[0] {
+                                0 => 1,
+                                1 => 2,
+                                2 => 4,
+                                _ => {
+                                    error!("Tried to write more than 32 bits");
+                                    break 'wow;
+                                }
                             };
-                            // info!("Read the value {} from address {}", value, addr);
+                            let addr = u16::from_le_bytes(msg_vec[1..3].try_into().unwrap());
+                            let value = unsafe {
+                                match size {
+                                    1 => x86_in::<u8>(addr) as u64,
+                                    2 => x86_in::<u16>(addr) as u64,
+                                    4 => x86_in::<u32>(addr) as u64,
+                                    _ => panic!("how?"),
+                                }
+                            };
+                            trace!("Read the value {} from address {}", value, addr);
                             vm.registers[1] = hbvm::value::Value(value);
-                        },
-                        1 => unsafe {
-                            let size = msg_vec[1];
-                            let addr =
-                                u16::from_le_bytes(msg_vec[2..4].try_into().unwrap_unchecked());
-                            // info!("Setting address {}", addr);
-
-                            match size {
-                                0 => x86_out(addr, msg_vec[4]),
-                                1 => x86_out(
-                                    addr,
-                                    u16::from_le_bytes(msg_vec[4..6].try_into().unwrap_unchecked()),
-                                ),
-                                2 => x86_out(
-                                    addr,
-                                    u32::from_le_bytes(msg_vec[4..8].try_into().unwrap_unchecked()),
-                                ),
-                                _ => panic!("How?"),
+                        }
+                        1 => 'wow: {
+                            let size = match msg_vec[1] {
+                                0 => 1,
+                                1 => 2,
+                                2 => 4,
+                                _ => {
+                                    error!("Tried to write more than 32 bits");
+                                    break 'wow;
+                                }
+                            };
+                            let addr = unsafe {
+                                u16::from_le_bytes(msg_vec[1..3].try_into().unwrap_unchecked())
+                            };
+                            trace!("Setting address {}", addr);
+                            unsafe {
+                                match size {
+                                    1 => x86_out(addr, msg_vec[3]),
+                                    2 => x86_out(
+                                        addr,
+                                        u16::from_le_bytes(
+                                            msg_vec[3..5].try_into().unwrap_unchecked(),
+                                        ),
+                                    ),
+                                    4 => x86_out(
+                                        addr,
+                                        u32::from_le_bytes(
+                                            msg_vec[3..7].try_into().unwrap_unchecked(),
+                                        ),
+                                    ),
+                                    _ => panic!("How?"),
+                                }
                             }
-                        },
+                        }
                         _ => {}
                     }
                 }
-                #[cfg(not(target_arch = "x86_64"))]
-                3 => unimplemented!("TODO: implement whatever buffer 3 does for no x86_64"),
                 // source of rng
                 4 => {
-                    let block = block_read(mem_addr, length);
-                    block.chunks_mut(8.min(length)).for_each(|chunk| {
-                        chunk.clone_from_slice(
-                            &crate::arch::hardware_random_u64().to_le_bytes()[..chunk.len()],
-                        );
-                    });
-                    vm.registers[1] = hbvm::value::Value(mem_addr);
+                    // limit to last 32 bits
+                    vm.registers[1] =
+                        hbvm::value::Value(crate::arch::hardware_random_u64() & 0xFFFFFFFF);
                 }
-                5 => match dt_msg_handler(vm, mem_addr, length) {
-                    Ok(()) => {}
-                    Err(_) => log::error!("Improper dt query"),
-                },
-                6 => unsafe {
-                    let program = block_read(mem_addr, length);
-
-                    // decode AbleOS Executable format
-                    let header = &program[0..46];
-                    let magic_slice = &header[0..3];
-                    if magic_slice != [0x15, 0x91, 0xD2] {
-                        log::error!("Invalid magic number at the start of executable.");
-                        return;
-                    }
-
-                    let executable_format_version =
-                        u32::from_le_bytes(header[3..7].try_into().unwrap());
-                    let offset = if executable_format_version == 0 {
-                        47
+                // get arch
+                5 => {
+                    if cfg!(target_arch = "x86_64") {
+                        vm.registers[1] = hbvm::value::Value(0);
+                    } else if cfg!(target_arch = "aarch64") {
+                        vm.registers[1] = hbvm::value::Value(1);
                     } else {
-                        error!("Invalid executable format.");
-                        return;
+                        vm.registers[1] = hbvm::value::Value(u64::MAX)
+                    }
+                }
+                // AbleCode™ (get fb ptr)
+                6 => {
+                    use {
+                        crate::kmain::FB_REQ,
+                        limine::{Framebuffer, NonNullPtr},
                     };
-
-                    let code_length = u64::from_le_bytes(header[7..15].try_into().unwrap());
-                    let data_length = u64::from_le_bytes(header[15..23].try_into().unwrap());
-                    let end = (code_length + data_length) as usize;
-                    log::debug!("{code_length} + {data_length} = {end}");
-
-                    let thr = ExecThread::new(&program[offset..end], Address::new(0));
-                    vm.registers[1] = Value(
-                        LazyCell::<Executor>::get_mut(&mut EXECUTOR)
-                            .unwrap()
-                            .spawn(Box::pin(async move {
-                                if let Err(e) = thr.await {
-                                    log::error!("{e:?}");
-                                }
-                            })) as u64,
-                    );
-                    log::debug!("spawned a process");
-                },
-
+                    let fb1: &NonNullPtr<Framebuffer> =
+                        &FB_REQ.get_response().get().unwrap().framebuffers()[0];
+                    let msg = block_read(mem_addr, length)[0];
+                    if msg == b'p' {
+                        // ptr
+                        let fb_front = fb1.address.as_ptr().unwrap() as *const u8;
+                        log::info!("Graphics front ptr {:?}", fb_front);
+                        vm.registers[1] = hbvm::value::Value(fb_front as u64);
+                    } else if msg == b'w' {
+                        // width
+                        log::info!("FB Width: {}", fb1.width);
+                        vm.registers[1] = hbvm::value::Value(fb1.width);
+                    } else if msg == b'h' {
+                        // height
+                        log::info!("FB Height: {}", fb1.height);
+                        vm.registers[1] = hbvm::value::Value(fb1.height);
+                    }
+                }
                 buffer_id => {
                     let mut buffs = IPC_BUFFERS.lock();
                     match buffs.get_mut(&buffer_id) {
                         Some(buff) => {
-                            let msg_vec = block_read(mem_addr, length);
-                            buff.push(msg_vec.to_vec());
-                            debug!("Sent Message {:?} to Buffer({})", msg_vec, buffer_id);
+                            let mut msg_vec = Vec::with_capacity(length);
+
+                            for x in 0..(length as isize) {
+                                let xyz = mem_addr as *const u8;
+                                let value = unsafe { xyz.offset(x).read() };
+                                msg_vec.push(value);
+                            }
+                            debug!(
+                                "Message {:?} has been sent to Buffer({})",
+                                msg_vec, buffer_id
+                            );
+                            buff.push(msg_vec);
                         }
                         None => {
                             log::error!("Access of non-existent buffer {}", buffer_id)
                         }
                     }
+                    drop(buffs);
                 }
             }
         }
         4 => {
             let buffer_id = vm.registers[3].cast::<u64>();
-            let map_ptr = vm.registers[4].cast::<u64>();
+            let mut map_ptr = vm.registers[4].cast::<u64>();
             let max_length = vm.registers[5].cast::<u64>();
 
             let mut buffs = IPC_BUFFERS.lock();
-            let buff: &mut IpcBuffer = match buffs.get_mut(&buffer_id) {
-                Some(buff) => buff,
-                None => panic!(
-                    "Failed to get buffer: id={buffer_id}, ptr={map_ptr}, length={max_length}"
-                ),
-            };
+            let buff: &mut IpcBuffer;
 
-            let msg = match buff.pop() {
-                Ok(msg) => msg,
-                Err(_) => return,
-            };
-            if msg.len() > unsafe { max_length.try_into().unwrap_unchecked() } {
+            if buffs.get_mut(&buffer_id).is_some() {
+                buff = buffs.get_mut(&buffer_id).unwrap();
+            } else {
+                // info!("AHHH");
+                vm.registers[1] = hbvm::value::Value(0);
+                return;
+            }
+            let pop = buff.pop();
+            if pop.is_err() {
+                return;
+            }
+            let msg = pop.unwrap();
+            if msg.len() > max_length.try_into().unwrap() {
                 info!("{}", max_length);
                 error!("Message is too long to map in.");
             } else {
                 unsafe {
-                    let ptr = map_ptr as *mut u8;
-                    ptr.copy_from_nonoverlapping(msg.as_ptr(), msg.len());
+                    let ptr: *mut u64 = &mut map_ptr;
+                    for (index, byte) in msg.iter().enumerate() {
+                        ptr.offset(index.try_into().unwrap()).write_bytes(*byte, 1);
+                    }
                 }
 
                 debug!("Recieve {:?} from Buffer({})", msg, buffer_id);
@@ -238,8 +255,14 @@ pub fn handler(vm: &mut Vm) {
             #[cfg(target_arch = "x86_64")]
             {
                 let r2 = vm.registers[2].cast::<u64>();
-                let x = hbvm::value::Value(unsafe { x86_in::<u8>(r2 as u16) } as u64);
-                // info!("Read {:?} from Port {:?}", x, r2);
+                unsafe fn x86_in(address: u16) -> u32 {
+                    x86_64::instructions::port::Port::new(address).read()
+                }
+                unsafe fn x86_out(address: u16, value: u32) {
+                    x86_64::instructions::port::Port::new(address).write(value);
+                }
+                let x = hbvm::value::Value(unsafe { x86_in(r2 as u16) } as u64);
+                info!("Read {:?} from Port {:?}", x, r2);
                 vm.registers[3] = x
             }
         }
@@ -249,8 +272,48 @@ pub fn handler(vm: &mut Vm) {
     }
 }
 
+fn log_msg_handler(_vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
+    // let message_length = 8 + 8 + 8;
+    // log::info!("Mem Addr 0x{:x?} length {}", mem_addr, length);
+    let msg_vec = block_read(mem_addr, length);
+
+    let log_level = msg_vec.last().unwrap();
+    match core::str::from_utf8(&msg_vec[1..]) {
+        Ok(strr) => {
+            // use LogLevel::*;
+            let _ll = match log_level {
+                0 | 48 => error!("{}", strr),
+                1 | 49 => warn!("{}", strr),
+                2 | 50 => info!("{}", strr),
+                3 | 51 => debug!("{}", strr),
+                4 | 52 => trace!("{}", strr),
+                _ => {
+                    return Err(LogError::InvalidLogFormat);
+                }
+            };
+        }
+        Err(e) => {
+            error!("{:?}", e);
+        }
+    }
+
+    Ok(())
+}
+
 #[derive(Debug)]
 pub enum LogError {
     NoMessages,
     InvalidLogFormat,
 }
+
+// use {alloc::vec, log::Record};
+// fn memory_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
+//     let mut val = alloc::vec::Vec::new();
+//     for _ in 0..4096 {
+//         val.push(0);
+//     }
+//     info!("Block address: {:?}", val.as_ptr());
+//     vm.registers[1] = hbvm::value::Value(val.as_ptr() as u64);
+//     vm.registers[2] = hbvm::value::Value(4096);
+//     Ok(())
+// }

kernel/src/holeybytes/kernel_services/dt_msg_handler.rs

@@ -1,78 +0,0 @@
-use {
-    crate::holeybytes::{kernel_services::block_read, Vm},
-    alloc::vec::Vec,
-};
-pub enum DtError {
-    QueryFailure,
-}
-
-pub fn dt_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), DtError> {
-    let msg_vec = block_read(mem_addr, length);
-    let query_string = core::str::from_utf8(
-        msg_vec
-            .split_once(|&byte| byte == 0)
-            .unwrap_or((msg_vec, &[]))
-            .0,
-    )
-    .unwrap();
-    log::trace!("Query {}", query_string);
-
-    let ret = query_parse(query_string);
-    log::trace!("Query response {}", ret);
-
-    vm.registers[1] = hbvm::value::Value(ret);
-
-    Ok(())
-}
-
-fn query_parse(query_string: &str) -> u64 {
-    let query = query_string.split('/').collect::<Vec<&str>>();
-
-    let first_fragment: &str = &query[0];
-    let ret = match first_fragment {
-        "framebuffer" => framebuffer_parse(query),
-        "cpu" => cpu_parse(query),
-
-        _ => 0,
-    };
-
-    return ret;
-}
-
-fn cpu_parse(qt_parse_step_two: Vec<&str>) -> u64 {
-    let second_fragment: &str = qt_parse_step_two[1];
-    match second_fragment {
-        // "architecture" => {
-        //     return 0;
-        // }
-        _ => {
-            return 0;
-        }
-    };
-}
-
-fn framebuffer_parse(qt_parse_step_two: Vec<&str>) -> u64 {
-    use crate::kmain::FB_REQ;
-    let fbs = &mut FB_REQ.get_response().get().unwrap().framebuffers();
-    let second_fragment: &str = qt_parse_step_two[1];
-    match second_fragment {
-        "fb0" => {
-            let fb_front = &fbs[0];
-            let third_fragment: &str = qt_parse_step_two[2];
-            let ret = match third_fragment {
-                "ptr" => {
-                    let ptr = fb_front.address.as_ptr().unwrap();
-                    ptr as usize as u64
-                }
-                "width" => fb_front.width,
-                "height" => fb_front.height,
-
-                _ => 0,
-            };
-            return ret;
-        }
-        _ => {
-            return 0;
-        }
-    };
-}

kernel/src/holeybytes/kernel_services/logging_service.rs

@@ -1,54 +0,0 @@
-use crate::holeybytes::{kernel_services::block_read, Vm};
-
-#[derive(Debug)]
-pub enum LogError {
-    InvalidLogFormat,
-}
-use log::Record;
-
-pub fn log_msg_handler(_vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
-    let msg_vec = block_read(mem_addr, length);
-
-    use log::Level::*;
-    let log_level = match msg_vec[0] {
-        0 | 48 => Error,
-        1 | 49 => Warn,
-        2 | 50 => Info,
-        3 | 51 => Debug,
-        4 | 52 => Trace,
-        _ => {
-            return Err(LogError::InvalidLogFormat);
-        }
-    };
-    if log_level > log::max_level() {
-        return Ok(());
-    }
-    let strptr = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap());
-    let strlen = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap()) as usize;
-
-    let str = block_read(strptr, strlen);
-
-    let file_name = "None";
-    let line_number = 0;
-
-    match core::str::from_utf8(&str) {
-        Ok(strr) => {
-            log::logger().log(
-                &Record::builder()
-                    .args(format_args!("{}", strr))
-                    .level(log_level)
-                    .target("Userspace")
-                    .file(Some(file_name))
-                    .line(Some(line_number))
-                    .module_path(Some(&file_name))
-                    .build(),
-            );
-        }
-
-        Err(e) => {
-            log::error!("{:?}", e);
-        }
-    }
-
-    Ok(())
-}

kernel/src/holeybytes/kernel_services/mem_serve.rs

@@ -1,6 +1,6 @@
 use {
     crate::holeybytes::{kernel_services::block_read, Vm},
-    alloc::alloc::{alloc, dealloc},
+    alloc::alloc::{alloc_zeroed, dealloc},
     core::alloc::Layout,
     log::{debug, info},
 };
@@ -17,28 +17,13 @@ pub enum MemoryQuotaType {
 }
 
 fn alloc_page(vm: &mut Vm, _mem_addr: u64, _length: usize) -> Result<(), MemoryServiceError> {
-    let ptr = unsafe { alloc(Layout::from_size_align_unchecked(4096, 8)) };
+    let ptr = unsafe { alloc_zeroed(Layout::new::<[u8; 4096]>()) };
     info!("Block address: {:?}", ptr);
     vm.registers[1] = hbvm::value::Value(ptr as u64);
     vm.registers[2] = hbvm::value::Value(4096);
     Ok(())
 }
 
-#[inline(always)]
-unsafe fn memset(dest: *mut u8, src: *const u8, count: usize, size: usize) {
-    let total_size = count * size;
-    src.copy_to_nonoverlapping(dest, size);
-
-    let mut copied = size;
-
-    while copied < total_size {
-        let copy_size = copied.min(total_size - copied);
-        dest.add(copied).copy_from_nonoverlapping(dest, copy_size);
-        copied += copy_size;
-    }
-}
-
-#[inline(always)]
 pub fn memory_msg_handler(
     vm: &mut Vm,
     mem_addr: u64,
@@ -47,35 +32,40 @@ pub fn memory_msg_handler(
     let msg_vec = block_read(mem_addr, length);
     let msg_type = msg_vec[0];
     match msg_type {
-        0 => unsafe {
+        0 => {
             let page_count = msg_vec[1];
+            let mptr_raw: [u8; 8] = msg_vec[2..10].try_into().unwrap();
+            let mptr: u64 = u64::from_le_bytes(mptr_raw);
 
-            let ptr = alloc(Layout::from_size_align_unchecked(
-                page_count as usize * 4096,
-                8,
-            ));
+            log::debug!("Allocating {} pages @ {:x}", page_count, mptr);
 
-            log::debug!("Allocating {} pages @ {:x}", page_count, ptr as u64);
+            let ptr = unsafe {
+                alloc_zeroed(Layout::from_size_align_unchecked(
+                    page_count as usize * 4096,
+                    1,
+                ))
+            };
 
             vm.registers[1] = hbvm::value::Value(ptr as u64);
             log::debug!("Kernel ptr: {:x}", ptr as u64);
-        },
+        }
 
-        1 => unsafe {
+        1 => {
             let page_count = msg_vec[1];
 
             let mptr_raw: [u8; 8] = msg_vec[2..10].try_into().unwrap();
             let mptr: u64 = u64::from_le_bytes(mptr_raw);
             log::debug!("Deallocating {} pages @ {:x}", page_count, mptr);
-
-            dealloc(
-                mptr as *mut u8,
-                Layout::from_size_align_unchecked(page_count as usize * 4096, 8),
-            )
-        },
+            unsafe {
+                dealloc(
+                    mptr as *mut u8,
+                    Layout::from_size_align_unchecked(page_count as usize * 4096, 1),
+                )
+            }
+        }
         2 => {
             use MemoryQuotaType::*;
-            let quota_type = match msg_vec[1] {
+            let quota_type = match msg_vec[0] {
                 0 => NoQuota,
                 1 => SoftQuota,
                 2 => HardQuota,
@@ -92,24 +82,10 @@ pub fn memory_msg_handler(
             )
         }
         3 => {
-            let page_count = msg_vec[1];
+            let page_count = msg_vec[0];
             log::debug!(" {} pages", page_count);
         }
-        4 => unsafe {
-            let count = u32::from_le_bytes(msg_vec[1..5].try_into().unwrap_unchecked()) as usize;
-            let src = u64::from_le_bytes(msg_vec[5..13].try_into().unwrap_unchecked()) as *const u8;
-            let dest = u64::from_le_bytes(msg_vec[13..21].try_into().unwrap_unchecked()) as *mut u8;
 
-            src.copy_to_nonoverlapping(dest, count);
-        },
-        5 => unsafe {
-            let count = u32::from_le_bytes(msg_vec[1..5].try_into().unwrap_unchecked()) as usize;
-            let size = u32::from_le_bytes(msg_vec[5..9].try_into().unwrap_unchecked()) as usize;
-            let src = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap_unchecked()) as *const u8;
-            let dest = u64::from_le_bytes(msg_vec[17..25].try_into().unwrap_unchecked()) as *mut u8;
-
-            memset(dest, src, count, size);
-        },
         _ => {
             log::debug!("Unknown memory service message type: {}", msg_type);
         }

kernel/src/holeybytes/kernel_services/mod.rs

@@ -1,11 +1,9 @@
 use core::slice;
 
-pub mod dt_msg_handler;
-pub mod logging_service;
 pub mod mem_serve;
 pub mod service_definition_service;
 
 #[inline(always)]
-pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a mut [u8] {
-    unsafe { slice::from_raw_parts_mut(mem_addr as *mut _, length) }
+pub fn block_read<'a>(mem_addr: u64, length: usize) -> &'a [u8] {
+    unsafe { slice::from_raw_parts(mem_addr as *const u8, length) }
 }

kernel/src/holeybytes/kernel_services/service_definition_service.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         arch::hardware_random_u64,
-        holeybytes::{kernel_services::block_read, Vm},
+        holeybytes::{ecah::LogError, kernel_services::block_read, Vm},
         ipc::{buffer::IpcBuffer, protocol::Protocol},
         kmain::IPC_BUFFERS,
     },
@@ -15,26 +15,28 @@ pub static SERVICES: Lazy<Mutex<Services>> = Lazy::new(|| {
     dt.0.insert(0, Protocol::void());
     Mutex::new(dt)
 });
-#[derive(Debug)]
-pub enum ServiceError {
-    InvalidFormat,
-}
-pub fn sds_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), ServiceError> {
+
+pub fn sds_msg_handler(vm: &mut Vm, mem_addr: u64, length: usize) -> Result<(), LogError> {
     let msg_vec = block_read(mem_addr, length);
+    if msg_vec.is_empty() {
+        return Err(LogError::NoMessages);
+    }
     let sds_event_type: ServiceEventType = msg_vec[0].into();
-    let strptr = u64::from_le_bytes(msg_vec[1..9].try_into().unwrap());
-    let strlen = u64::from_le_bytes(msg_vec[9..17].try_into().unwrap()) as usize;
-    let string_vec = block_read(strptr, strlen);
-    let string = core::str::from_utf8(string_vec).expect("Our bytes should be valid utf8");
+
+    // info!("Length {}", msg_vec.len());
 
     use ServiceEventType::*;
     match sds_event_type {
         CreateService => {
+            let string =
+                core::str::from_utf8(&msg_vec[1..]).expect("Our bytes should be valid utf8");
             let ret = sds_create_service(string);
             vm.registers[1] = hbvm::value::Value(ret as u64);
         }
         DeleteService => todo!(),
         SearchServices => {
+            let string =
+                core::str::from_utf8(&msg_vec[1..]).expect("Our bytes should be valid utf8");
             let ret = sds_search_service(string);
             vm.registers[1] = hbvm::value::Value(ret as u64);
         }
@@ -92,7 +94,8 @@ fn sds_create_service(protocol: &'static str) -> u64 {
     // let a: protocol::Protocol = protocol.into();
     buff_id
 }
-pub fn sds_search_service(protocol: &str) -> u64 {
+
+fn sds_search_service(protocol: &str) -> u64 {
     let services = SERVICES.lock();
     let compare = Protocol::from(protocol);
     for (bid, protocol_canidate) in &services.0 {

kernel/src/holeybytes/mem.rs

@@ -30,29 +30,30 @@ impl Memory {
 }
 
 impl hbvm::mem::Memory for Memory {
-    #[inline(always)]
+    #[inline]
     unsafe fn load(
         &mut self,
         addr: Address,
         target: *mut u8,
         count: usize,
     ) -> Result<(), hbvm::mem::LoadError> {
-        core::ptr::copy_nonoverlapping(addr.get() as *const u8, target, count);
+        if addr.get() % 4096 == 0 {}
+        core::ptr::copy(addr.get() as *const u8, target, count);
         Ok(())
     }
 
-    #[inline(always)]
+    #[inline]
     unsafe fn store(
         &mut self,
         addr: Address,
         source: *const u8,
         count: usize,
     ) -> Result<(), hbvm::mem::StoreError> {
-        core::ptr::copy_nonoverlapping(source, addr.get() as *mut u8, count);
+        core::ptr::copy(source, addr.get() as *mut u8, count);
         Ok(())
     }
 
-    #[inline(always)]
+    #[inline]
     unsafe fn prog_read<T: Copy>(&mut self, addr: Address) -> T {
         (addr.get() as *const T).read()
     }

kernel/src/holeybytes/mod.rs

@@ -1,9 +1,9 @@
 mod ecah;
-pub mod kernel_services;
+mod kernel_services;
 mod mem;
 
 use {
-    alloc::alloc::{alloc, dealloc},
+    alloc::alloc::{alloc_zeroed, dealloc},
     core::{
         alloc::Layout,
         future::Future,
@@ -61,22 +61,28 @@ impl<'p> Future for ExecThread {
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match self.vm.run() {
             Err(err) => {
-                log::error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers,);
-                return Poll::Ready(Err(err));
+                error!("HBVM Error\r\nRegister dump: {:?}", self.vm.registers);
+                Poll::Ready(Err(err))
+            }
+            Ok(VmRunOk::End) => Poll::Ready(Ok(())),
+            Ok(VmRunOk::Ecall) => {
+                ecah::handler(&mut self.vm);
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+            Ok(VmRunOk::Timer) => {
+                cx.waker().wake_by_ref();
+                Poll::Pending
             }
-            Ok(VmRunOk::End) => return Poll::Ready(Ok(())),
-            Ok(VmRunOk::Ecall) => ecah::handler(&mut self.vm),
-            Ok(VmRunOk::Timer) => (),
             Ok(VmRunOk::Breakpoint) => {
-                log::error!(
+                error!(
                     "HBVM Debug breakpoint\r\nRegister dump: {:?}",
-                    self.vm.registers,
+                    self.vm.registers
                 );
+                cx.waker().wake_by_ref();
+                Poll::Pending
             }
         }
-
-        cx.waker().wake_by_ref();
-        Poll::Pending
     }
 }
 
@@ -97,10 +103,10 @@ impl HandlePageFault for PageFaultHandler {
 
 #[inline(always)]
 const fn stack_layout() -> Layout {
-    unsafe { Layout::from_size_align_unchecked(STACK_SIZE, 8) }
+    unsafe { Layout::from_size_align_unchecked(STACK_SIZE, 4096) }
 }
 
 #[inline(always)]
 fn allocate_stack() -> *mut u8 {
-    unsafe { alloc(stack_layout()) }
+    unsafe { alloc_zeroed(stack_layout()) }
 }

kernel/src/ipc/buffer.rs

@@ -49,7 +49,9 @@ impl<'a> IpcBuffer<'a> {
     pub fn push(&mut self, msg: Message) {
         match &self.buffer {
             BufferTypes::Unbound(buff) => buff.push(msg),
-            BufferTypes::Bound(buff) => buff.push(msg).unwrap(),
+            BufferTypes::Bound(buff) => {
+                let _ = buff.push(msg);
+            }
         };
     }
     pub fn pop(&mut self) -> Result<Message, IpcError> {

kernel/src/ipc/protocol.rs

@@ -1,15 +1,18 @@
-use {alloc::vec::Vec, hashbrown::HashMap};
+use {
+    alloc::{string::String, vec::Vec},
+    hashbrown::HashMap,
+};
 #[derive(Debug, PartialEq, Clone)]
 pub struct Type {}
 #[derive(Debug, PartialEq, Clone)]
-pub struct Funct<'a> {
-    takes: Vec<&'a str>,
-    gives: Vec<&'a str>,
+pub struct Funct {
+    takes: Vec<String>,
+    gives: Vec<String>,
 }
 #[derive(Debug, PartialEq, Clone)]
 pub struct Protocol<'a> {
     types: HashMap<&'a str, Type>,
-    fns:   HashMap<&'a str, Funct<'a>>,
+    fns:   HashMap<&'a str, Funct>,
 }
 impl<'a> Protocol<'a> {
     pub fn void() -> Self {

kernel/src/kmain.rs

@@ -8,14 +8,11 @@ use {
         device_tree::DeviceTree,
         holeybytes::ExecThread,
         ipc::buffer::IpcBuffer,
-        task::Executor,
     },
-    alloc::boxed::Box,
-    core::cell::LazyCell,
     hashbrown::HashMap,
     hbvm::mem::Address,
     limine::{Framebuffer, FramebufferRequest, NonNullPtr},
-    log::{debug, error, trace},
+    log::{debug, info},
     spin::{Lazy, Mutex},
 };
 
@@ -39,9 +36,9 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     let dt = DEVICE_TREE.lock();
 
     // TODO(Able): This line causes a deadlock
-    debug!("Device Tree: {}", dt);
+    info!("Device Tree: {}", dt);
 
-    trace!("Boot complete. Moving to init_system");
+    info!("Boot complete. Moving to init_system");
 
     // TODO: schedule the disk driver from the initramfs
     // TODO: schedule the filesystem driver from the initramfs
@@ -53,73 +50,49 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     let fb1: &NonNullPtr<Framebuffer> = &FB_REQ.get_response().get().unwrap().framebuffers()[0];
 
     {
+        use crate::alloc::string::ToString;
         let mut dt = DEVICE_TREE.lock();
         let mut disp = xml::XMLElement::new("display_0");
 
         disp.set_attribute("width", fb1.width);
         disp.set_attribute("height", fb1.height);
-        disp.set_attribute("bpp", fb1.bpp);
+        disp.set_attribute("bits per pixel", fb1.bpp);
         disp.set_attribute("pitch", fb1.pitch);
-        dt.devices.insert("Displays", alloc::vec![disp]);
+        dt.devices.insert("Displays".to_string(), alloc::vec![disp]);
     }
-    debug!("Graphics initialised");
-    debug!(
+    log::info!("Graphics initialised");
+    log::info!(
         "Graphics front ptr {:?}",
         fb1.address.as_ptr().unwrap() as *const u8
     );
 
+    let mut executor = crate::task::Executor::new(256);
+    let bm_take = boot_modules.len();
     unsafe {
-        let executor = LazyCell::<Executor>::force_mut(&mut EXECUTOR);
-        for module in boot_modules.iter() {
-            let cmd = module.cmd.trim_matches('"');
+        for module in boot_modules.into_iter().take(bm_take) {
+            let mut cmd = module.cmd;
+            if cmd.len() > 2 {
+                // // Remove the quotes
+                // cmd.remove(0);
+                // cmd.pop();
+                cmd = &cmd[1..cmd.len()]
+            }
             let cmd_len = cmd.len() as u64;
 
-            log::info!(
-                "Starting {}",
-                module
-                    .path
-                    .split('/')
-                    .last()
-                    .unwrap()
-                    .split('.')
-                    .next()
-                    .unwrap()
-            );
-            log::debug!("Spawning {} with arguments \"{}\"", module.path, cmd);
+            log::info!("Spawning {} with arguments \"{}\"", module.path, cmd);
 
-            // decode AbleOS Executable format
-            let header = &module.bytes[0..46];
-            let magic_slice = &header[0..3];
-            if magic_slice != [0x15, 0x91, 0xD2] {
-                log::error!("Invalid magic number at the start of executable.");
-                continue;
-            }
-
-            let executable_format_version = u32::from_le_bytes(header[3..7].try_into().unwrap());
-            let offset = if executable_format_version == 0 {
-                47
-            } else {
-                error!("Invalid executable format.");
-                continue;
-            };
-
-            let code_length = u64::from_le_bytes(header[7..15].try_into().unwrap());
-            let data_length = u64::from_le_bytes(header[15..23].try_into().unwrap());
-            let end = (code_length + data_length) as usize;
-            log::debug!("{code_length} + {data_length} = {end}");
-
-            let mut thr = ExecThread::new(&module.bytes[offset..end], Address::new(0));
-            if cmd_len > 0 {
-                thr.set_arguments(cmd.as_ptr() as u64, cmd_len);
-            }
-            executor.spawn(Box::pin(async move {
+            executor.spawn(async move {
+                let mut thr = ExecThread::new(&module.bytes, Address::new(0));
+                if cmd_len > 0 {
+                    thr.set_arguments(cmd.as_bytes().as_ptr() as u64, cmd_len);
+                }
                 if let Err(e) = thr.await {
                     log::error!("{e:?}");
                 }
-            }));
+            })
         }
 
-        debug!("Random number: {}", hardware_random_u64());
+        info!("Random number: {}", hardware_random_u64());
 
         executor.run();
     };
@@ -127,10 +100,6 @@ pub fn kmain(_cmdline: &str, boot_modules: BootModules) -> ! {
     crate::arch::spin_loop()
 }
 
-// ! SAFETY: this is not threadsafe at all, like even a little bit.
-// ! SERIOUSLY
-pub static mut EXECUTOR: LazyCell<Executor> = LazyCell::new(|| Executor::new());
-
 pub static DEVICE_TREE: Lazy<Mutex<DeviceTree>> = Lazy::new(|| {
     let dt = DeviceTree::new();
     Mutex::new(dt)

kernel/src/lib.rs

@@ -2,12 +2,9 @@
 //! Named akern.
 //! Akern is woefully undersupported at the moment but we are looking to add support improve hardware discovery and make our lives as kernel and operating system developers easier and better
 #![no_std]
+#![feature(new_uninit)]
 #![feature(
-    slice_split_once,
-    exclusive_wrapper,
-    core_intrinsics,
     abi_x86_interrupt,
-    lazy_get,
     alloc_error_handler,
     ptr_sub_ptr,
     custom_test_frameworks,
@@ -15,7 +12,8 @@
     pointer_is_aligned_to
 )]
 #![test_runner(crate::test_runner)]
-#![allow(dead_code, internal_features, static_mut_refs)]
+#![cfg_attr(not(debug_assertions), allow(unused, deprecated))]
+#![allow(dead_code)]
 extern crate alloc;
 
 mod allocator;
@@ -23,7 +21,6 @@ mod arch;
 mod bootmodules;
 mod capabilities;
 mod device_tree;
-mod exe_format;
 mod handle;
 mod holeybytes;
 mod ipc;

kernel/src/logger.rs

@@ -36,26 +36,13 @@ impl log::Log for Logger {
             Level::Debug => "25",
             Level::Trace => "103",
         };
-        let module = record
-            .module_path()
-            .unwrap_or_default()
-            .rsplit_once(':')
-            .unwrap_or_default()
-            .1;
-        if module == "" {
-            crate::arch::log(format_args!(
-                "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m: {}\r\n",
-                record.args(),
-            ))
-            .expect("write to serial console");
-        } else {
-            let line = record.line().unwrap_or_default();
-            crate::arch::log(format_args!(
-                "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m [{module}:{line}]: {}\r\n",
-                record.args(),
-            ))
-            .expect("write to serial console");
-        }
+        let module = record.module_path().unwrap_or_default();
+        let line = record.line().unwrap_or_default();
+        crate::arch::log(format_args!(
+            "\x1b[38;5;{lvl_color}m{lvl}\x1b[0m [{module}:{line}]: {}\r\n",
+            record.args(),
+        ))
+        .expect("write to serial console");
     }
 
     fn flush(&self) {}

kernel/src/task.rs

@@ -29,24 +29,24 @@ pub fn yield_now() -> impl Future<Output = ()> {
     YieldNow(false)
 }
 
-pub struct Executor {
-    tasks:      Slab<Task>,
+pub struct Executor<F: Future<Output = ()> + Send> {
+    tasks:      Slab<Task<F>>,
     task_queue: Arc<TaskQueue>,
 }
 
-impl Executor {
-    pub fn new() -> Self {
+impl<F: Future<Output = ()> + Send> Executor<F> {
+    pub fn new(size: usize) -> Self {
         Self {
-            tasks:      Slab::new(),
+            tasks:      Slab::with_capacity(size),
             task_queue: Arc::new(TaskQueue::new()),
         }
     }
 
     #[inline]
-    pub fn spawn(&mut self, future: Pin<Box<dyn Future<Output = ()> + Send>>) -> usize {
-        let id = self.tasks.insert(Task::new(future));
-        self.task_queue.queue.push(id);
-        id
+    pub fn spawn(&mut self, future: F) {
+        self.task_queue
+            .queue
+            .push(self.tasks.insert(Task::new(future)));
     }
 
     pub fn run(&mut self) {
@@ -83,17 +83,17 @@ impl Executor {
     }
 }
 
-struct Task {
-    future: Pin<Box<dyn Future<Output = ()> + Send>>,
+struct Task<F: Future<Output = ()> + Send> {
+    future: Pin<Box<F>>,
     waker:  Option<TaskWaker>,
 }
 
-impl Task {
+impl<F: Future<Output = ()> + Send> Task<F> {
     #[inline(always)]
-    pub fn new(future: Pin<Box<dyn Future<Output = ()> + Send>>) -> Self {
+    pub fn new(future: F) -> Self {
         Self {
-            future,
-            waker: None,
+            future: Box::pin(future),
+            waker:  None,
         }
     }
 

kernel/src/utils.rs

@@ -4,14 +4,15 @@
 /// Used when tab `\t` in hardware is not known and we will default to two spaces
 pub const TAB: &str = "  ";
 
+
 // NOTE: this only reduces the code duplication in source code not in generated code!
 // Written by Yours Truly: Munir
 /// A simple macro to reduce code duplication when we use TAB internally
 #[macro_export]
 macro_rules! tab {
-    ($num:expr) => {
+    ($num:expr) => { 
         TAB.repeat($num)
-    };
+    }
 }
 
 // NOTE: this only reduces the code duplication in source code not in generated code!
@@ -21,7 +22,7 @@ macro_rules! tab {
 macro_rules! device_tree {
     ($devtree:expr, $dev_type_vec:expr) => {
         for each_device_type in $dev_type_vec {
-            $devtree.devices.insert(each_device_type, Vec::new());
+            $devtree.devices.insert(each_device_type.to_string(), Vec::new());
         }
     };
 }
@@ -49,4 +50,4 @@ macro_rules! cpu_features {
         $result_vec.push(("rdseed", rdseed));
         $result_vec.push(("x2apic", x2));
     };
-}
+}

kernel/targets/aarch64-virt-ableos.json

@@ -1,6 +1,6 @@
 {
     "arch": "aarch64",
-    "data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32",
+    "data-layout": "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128",
     "disable-redzone": true,
     "env": "",
     "executables": true,

kernel/targets/x86_64-ableos.json

@@ -1,22 +1,22 @@
 {
-	"llvm-target": "x86_64-unknown-none",
-	"data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
-	"arch": "x86_64",
-	"target-endian": "little",
-	"target-pointer-width": "64",
-	"target-c-int-width": "32",
-	"os": "none",
-	"executables": true,
-	"linker-flavor": "ld.lld",
-	"linker": "rust-lld",
-	"panic-strategy": "abort",
-	"disable-redzone": true,
-	"features": "",
-	"code-model": "kernel",
-	"pre-link-args": {
-		"ld.lld": [
-			"--gc-sections",
-			"--script=kernel/lds/x86_64.ld"
-		]
-	}
+    "llvm-target": "x86_64-unknown-none",
+    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
+    "arch": "x86_64",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "target-c-int-width": "32",
+    "os": "none",
+    "executables": true,
+    "linker-flavor": "ld.lld",
+    "linker": "rust-lld",
+    "panic-strategy": "abort",
+    "disable-redzone": true,
+    "features": "",
+    "code-model": "kernel",
+    "pre-link-args": {
+        "ld.lld": [
+            "--gc-sections",
+            "--script=kernel/lds/x86_64.ld"
+        ]
+    }
 }

kernel/targets/x86_64_v3-ableos.json

@@ -1,22 +0,0 @@
-{
-	"llvm-target": "x86_64-unknown-none",
-	"data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
-	"arch": "x86_64",
-	"target-endian": "little",
-	"target-pointer-width": "64",
-	"target-c-int-width": "32",
-	"os": "none",
-	"executables": true,
-	"linker-flavor": "ld.lld",
-	"linker": "rust-lld",
-	"panic-strategy": "abort",
-	"disable-redzone": true,
-	"features": "+sse4.1,+avx,+aes,+fma,+popcnt,+bmi2,+avx2,+lzcnt,+xsave",
-	"code-model": "kernel",
-	"pre-link-args": {
-		"ld.lld": [
-			"--gc-sections",
-			"--script=kernel/lds/x86_64.ld"
-		]
-	}
-}

known_bugs.md

@@ -1,2 +0,0 @@
-# i did not know where to put this
-- memcpy / memset cause crash on debug builds due to ptr misalignment that is not present on release builds

repbuild/Cargo.toml

@@ -6,15 +6,24 @@ edition = "2021"
 [dependencies]
 str-reader = "0.1"
 derive_more = { version = "1", default-features = false, features = [
-	"display",
+  "add",
+  "add_assign",
+  "constructor",
+  "display",
+  "from",
+  "into",
+  "mul",
+  "mul_assign",
+  "not",
+  "sum",
 ] }
 error-stack = "0.5"
-fatfs = { version = "0.3", default-features = false, features = [
-	"std",
-	"alloc",
-] }
+fatfs = "0.3"
 toml = "0.8"
+# hbasm.git = "https://git.ablecorp.us/AbleOS/holey-bytes.git"
 hblang.git = "https://git.ablecorp.us/AbleOS/holey-bytes.git"
-log = "0.4"
-raw-cpuid = "11"
-ureq = { version = "2", default-features = false, features = ["tls"] }
+
+[dependencies.reqwest]
+version = "0.12"
+default-features = false
+features = ["rustls-tls", "blocking"]

repbuild/src/dev.rs

@@ -1,6 +1,5 @@
 #![allow(unused)]
 use std::{
-    collections::HashMap,
     fmt::format,
     fs::{read_to_string, File},
     io::{BufWriter, Write},
@@ -14,7 +13,6 @@ pub struct Package {
     name:      String,
     binaries:  Vec<String>,
     build_cmd: String,
-    args:      HashMap<String, String>,
 }
 
 impl Package {
@@ -48,79 +46,57 @@ impl Package {
         let mut binaries = vec![];
 
         for (count, (name, table)) in bin_table.into_iter().enumerate() {
+            // if count != 0 {
+            println!("{}", name);
             binaries.push(name.clone());
+            // }
         }
         let build_table = data.get("build").unwrap();
 
         let mut build_cmd: String = build_table.get("command").unwrap().as_str().unwrap().into();
         build_cmd.remove(0);
-        let mut args: HashMap<String, String> = match build_table.get("args") {
-            None => HashMap::new(),
-            Some(v) => v
-                .as_table()
-                .unwrap()
-                .into_iter()
-                .map(|(k, v)| (k.clone(), v.to_string()))
-                .collect::<HashMap<String, String>>(),
-        };
+        // build_cmd.pop();
 
         Self {
             name,
             binaries,
             build_cmd,
-            args,
         }
     }
-    pub fn build(&self, out: &mut Vec<u8>) -> std::io::Result<()> {
+    pub fn build(&self) {
         if self.binaries.contains(&"hblang".to_string()) {
             let file = self.build_cmd.split_ascii_whitespace().last().unwrap();
+
             let path = format!("sysdata/programs/{}/{}", self.name, file);
+            let mut bytes = Vec::new();
             // compile here
 
-            let mut warnings = String::new();
-
-            hblang::run_compiler(
+            let _ = hblang::run_compiler(
                 &path,
                 Options {
                     fmt: true,
-                    in_house_regalloc: true,
                     ..Default::default()
                 },
-                out,
-                &mut warnings,
-            )?;
+                &mut bytes,
+            );
+            let _ = hblang::run_compiler(&path, Default::default(), &mut bytes);
 
             match std::fs::create_dir("target/programs") {
                 Ok(_) => (),
                 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => (),
                 Err(e) => panic!("{}", e),
             }
-
-            hblang::run_compiler(
-                &path,
-                Options {
-                    in_house_regalloc: true,
-                    ..Default::default()
-                },
-                out,
-                &mut warnings,
-            )?;
-            std::fs::write(format!("target/programs/{}.hbf", self.name), &out)?;
-            out.clear();
-
-            hblang::run_compiler(
+            std::fs::write(format!("target/programs/{}.hbf", self.name), &bytes).unwrap();
+            bytes.clear();
+            let _ = hblang::run_compiler(
                 &path,
                 Options {
                     dump_asm: true,
-                    in_house_regalloc: true,
                     ..Default::default()
                 },
-                out,
-                &mut warnings,
-            )?;
-            std::fs::write(format!("target/programs/{}.hba", self.name), &out)?;
-            out.clear();
+                &mut bytes,
+            );
+            std::fs::write(format!("target/programs/{}.hba", self.name), &bytes).unwrap();
         }
-        Ok(())
     }
 }

repbuild/src/main.rs

@@ -1,16 +1,18 @@
+// #![allow(unused)]
+
 mod dev;
 
 use {
-    core::fmt::Write as _,
     derive_more::Display,
     dev::Package,
     error_stack::{bail, report, Context, Report, Result, ResultExt},
     fatfs::{FileSystem, FormatVolumeOptions, FsOptions, ReadWriteSeek},
     std::{
+        // fmt::Display,
         fs::{self, File},
         io::{self, Write},
         path::Path,
-        process::{exit, Command, Stdio},
+        process::{exit, Command},
     },
     toml::Value,
 };
@@ -19,9 +21,6 @@ fn main() -> Result<(), Error> {
     let mut args = std::env::args();
     args.next();
 
-    log::set_logger(&hblang::Logger).unwrap();
-    log::set_max_level(log::LevelFilter::Error);
-
     match args.next().as_deref() {
         Some("build" | "b") => {
             let mut release = false;
@@ -36,8 +35,6 @@ fn main() -> Result<(), Error> {
                     target = Target::Riscv64Virt;
                 } else if arg == "arm64" || arg == "aarch64" || arg == "aarch64-virt" {
                     target = Target::Aarch64;
-                } else if arg == "avx2" {
-                    target = Target::X86_64Avx2;
                 } else {
                     return Err(report!(Error::InvalidSubCom));
                 }
@@ -49,7 +46,6 @@ fn main() -> Result<(), Error> {
             let mut release = false;
             let mut debuginfo = false;
             let mut target = Target::X86_64;
-            let mut do_accel = true;
             for arg in args {
                 if arg == "-r" || arg == "--release" {
                     release = true;
@@ -59,17 +55,13 @@ fn main() -> Result<(), Error> {
                     target = Target::Riscv64Virt;
                 } else if arg == "arm64" || arg == "aarch64" || arg == "aarch64-virt" {
                     target = Target::Aarch64;
-                } else if arg == "--noaccel" {
-                    do_accel = false;
-                } else if arg == "avx2" {
-                    target = Target::X86_64Avx2;
                 } else {
                     return Err(report!(Error::InvalidSubCom));
                 }
             }
 
             build(release, target, debuginfo)?;
-            run(release, target, do_accel)
+            run(release, target)
         }
         Some("help" | "h") => {
             println!(concat!(
@@ -79,10 +71,8 @@ fn main() -> Result<(), Error> {
                 "   help (h): Print this message\n",
                 "    run (r): Build and run AbleOS in QEMU\n\n",
                 "Options for build and run:\n",
-                "        -r / --release: build in release mode\n",
-                "        -d / --debuginfo: build with debug info\n",
-                "        --noaccel: run without acceleration (e.g, no kvm)\n",
-                "[ rv64 / riscv64 / riscv64-virt / aarch64 / arm64 / aarch64-virt / avx2 ]: sets target"
+                "        -r: build in release mode",
+                "  [target]: sets target"
             ),);
             Ok(())
         }
@@ -205,43 +195,21 @@ TERM_BACKDROP={}
         let modules = value.get_mut("modules").unwrap().as_table_mut().unwrap();
         // let mut real_modules = modules.clone();
 
-        let mut errors = String::new();
-        let mut out = Vec::new();
-
-        modules
-            .into_iter()
-            .map(|(_, value)| -> Result<(), io::Error> {
-                if value.is_table() {
-                    let path = get_path_without_boot_prefix(
-                        value.get("path").expect("You must have `path` as a value"),
-                    )
-                    .unwrap()
-                    .split(".")
-                    .next()
-                    .unwrap();
-                    let p = Package::load_from_file(
-                        format!("sysdata/programs/{}/meta.toml", path).to_owned(),
-                    );
-                    match p.build(&mut out) {
-                        Ok(()) => {}
-                        Err(_) => {
-                            writeln!(errors, "========= while compiling {} =========", path)
-                                .unwrap();
-                            errors.push_str(core::str::from_utf8(&out).expect("no"));
-                            out.clear();
-                        }
-                    }
-                }
-                Ok(())
-            })
-            .for_each(drop);
-
-        if !errors.is_empty() {
-            let _ = writeln!(errors, "!!! STOPPING DUE TO PREVIOUS ERRORS !!!");
-            std::eprint!("{errors}");
-            continue;
-        }
-
+        modules.into_iter().for_each(|(_, value)| {
+            if value.is_table() {
+                let path = get_path_without_boot_prefix(
+                    value.get("path").expect("You must have `path` as a value"),
+                )
+                .unwrap()
+                .split(".")
+                .next()
+                .unwrap();
+                let p = Package::load_from_file(
+                    format!("sysdata/programs/{}/meta.toml", path).to_owned(),
+                );
+                p.build();
+            }
+        });
         modules.into_iter().for_each(|(_key, value)| {
             if value.is_table() {
                 let path = value.get("path").expect("You must have `path` as a value");
@@ -328,9 +296,6 @@ fn build(release: bool, target: Target, debuginfo: bool) -> Result<(), Error> {
     if target == Target::Aarch64 {
         com.args(["--target", "targets/aarch64-virt-ableos.json"]);
     }
-    if target == Target::X86_64Avx2 {
-        com.args(["--target", "targets/x86_64_v3-ableos.json"]);
-    }
 
     match com.status() {
         Ok(s) if s.code() != Some(0) => bail!(Error::Build),
@@ -344,10 +309,6 @@ fn build(release: bool, target: Target, debuginfo: bool) -> Result<(), Error> {
             path.push_str("_x86-64");
             "target/x86_64-ableos"
         }
-        Target::X86_64Avx2 => {
-            path.push_str("_x86-64");
-            "target/x86_64_v3-ableos"
-        }
         Target::Riscv64Virt => "target/riscv64-virt-ableos",
         Target::Aarch64 => {
             path.push_str("_aarch64");
@@ -370,68 +331,25 @@ fn build(release: bool, target: Target, debuginfo: bool) -> Result<(), Error> {
     .change_context(Error::Io)
 }
 
-fn run(release: bool, target: Target, do_accel: bool) -> Result<(), Error> {
-    let target_str = match target {
-        Target::X86_64 | Target::X86_64Avx2 => "qemu-system-x86_64",
-        Target::Riscv64Virt => "qemu-system-riscv64",
-        Target::Aarch64 => "qemu-system-aarch64",
+fn run(release: bool, target: Target) -> Result<(), Error> {
+    let mut com = match target {
+        Target::X86_64 => Command::new("qemu-system-x86_64"),
+        Target::Riscv64Virt => Command::new("qemu-system-riscv64"),
+        Target::Aarch64 => Command::new("qemu-system-aarch64"),
     };
-    let (mut com, mut com2) = (Command::new(target_str), Command::new(target_str));
     let ovmf_path = fetch_ovmf(target);
-    #[cfg(target_arch = "x86_64")]
-    let accel = if do_accel {
-        let supported = String::from_utf8(
-            com2.args(["--accel", "help"])
-                .stdout(Stdio::piped())
-                .stderr(Stdio::piped())
-                .spawn()
-                .unwrap()
-                .wait_with_output()
-                .unwrap()
-                .stdout,
-        )
-        .unwrap();
-
-        let cpuid = raw_cpuid::CpuId::new();
-        let vmx = cpuid.get_feature_info().unwrap().has_vmx();
-        let svm = cpuid.get_svm_info().is_some();
-
-        if supported.contains("kvm") && (vmx || svm) {
-            "accel=kvm"
-        } else if cpuid
-            .get_processor_brand_string()
-            .filter(|a| a.as_str() == "GenuineIntel")
-            .is_some()
-            && supported.contains("hax")
-            && vmx
-        {
-            "accel=hax"
-        } else if supported.contains("whpx") {
-            "accel=whpx"
-        } else {
-            "accel=tcg"
-        }
-    } else {
-        "accel=tcg"
-    };
-    #[cfg(not(target_arch = "x86_64"))]
-    let accel = "accel=tcg";
 
     match target {
-        Target::X86_64 | Target::X86_64Avx2 => {
+        Target::X86_64 => {
             #[rustfmt::skip]
             com.args([
                 "-bios", &ovmf_path.change_context(Error::OvmfFetch)?,
                 "-drive", "file=target/disk.img,format=raw",
-                "-device", "vmware-svga",
-                // "-serial", "stdio",
-                "-m", "2G",
-                "-smp", "1",
-                "-parallel", "none",
-                "-monitor", "none",
-                "-machine", accel,
-                "-cpu", "max",
-                "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04",
+                "-m", "4G",
+                "-smp", "cores=4",
+                "-enable-kvm",
+                "-cpu", "host",
+                "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04"
             ]);
         }
         Target::Riscv64Virt => {
@@ -475,7 +393,7 @@ fn run(release: bool, target: Target, do_accel: bool) -> Result<(), Error> {
 
 fn fetch_ovmf(target: Target) -> Result<String, OvmfFetchError> {
     let (ovmf_url, ovmf_path) = match target {
-        Target::X86_64 | Target::X86_64Avx2 => (
+        Target::X86_64 => (
             "https://retrage.github.io/edk2-nightly/bin/RELEASEX64_OVMF.fd",
             "target/RELEASEX64_OVMF.fd",
         ),
@@ -497,12 +415,12 @@ fn fetch_ovmf(target: Target) -> Result<String, OvmfFetchError> {
         Ok(_) => return Ok(ovmf_path.to_owned()),
         Err(e) => return Err(report!(e).change_context(OvmfFetchError::Io)),
     };
-    let req = ureq::get(ovmf_url)
-        .call()
+    let mut bytes = reqwest::blocking::get(ovmf_url)
         .map_err(Report::from)
         .change_context(OvmfFetchError::Fetch)?;
 
-    std::io::copy(&mut req.into_reader(), &mut file)
+    bytes
+        .copy_to(&mut file)
         .map_err(Report::from)
         .change_context(OvmfFetchError::Io)?;
 
@@ -524,7 +442,6 @@ impl Context for OvmfFetchError {}
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Target {
     X86_64,
-    X86_64Avx2,
     Riscv64Virt,
     Aarch64,
 }

rust-toolchain.toml

@@ -1,5 +1,3 @@
 [toolchain]
-# old toolchain
-# channel = "nightly-2024-07-27"
-channel = "nightly"
+channel = "nightly-2024-07-27"
 components = ["rust-src", "llvm-tools"]

sysdata/assets/consolefonts/tamsyn/LICENSE

@@ -1,10 +0,0 @@
-Tamsyn font is free.  You are hereby granted permission to use, copy, modify,
-and distribute it as you see fit.
-
-Tamsyn font is provided "as is" without any express or implied warranty.
-
-The author makes no representations about the suitability of this font for
-a particular purpose.
-
-In no event will the author be held liable for damages arising from the use
-of this font.

sysdata/idl/abc/src/protocol.aidl

@@ -0,0 +1,2 @@
+protocol abc {
+                }

sysdata/idl/log/src/protocol.aidl

@@ -1,24 +0,0 @@
-@auto_increment
-enum LogLevel {
-    Error = 0,
-    Warn,
-    Info,
-    Debug,
-    Trace,
-}
-
-@auto_increment
-enum LogResult {
-    Err = 0,
-    Ok,
-}
-
-struct Log {
-    log_level: LogLevel,
-}
-
-@visibility(public)
-protocol Log {
-    fn log(Log) -> LogResult;
-    fn flush() -> LogResult;
-}

sysdata/libraries/horizon_api/examples/horizontal.lui

@@ -1,4 +0,0 @@
-(horizontal
-    spacing : 10
-    (label "hi")
-    (label "goodbye"))

sysdata/libraries/horizon_api/examples/label.lui

@@ -1 +0,0 @@
-(label "hello")

sysdata/libraries/horizon_api/examples/vertical.lui

@@ -1,3 +0,0 @@
-(vertical
-    (label "hello")
-    (label "hello" color:red))

sysdata/libraries/horizon_api/src/element.hb

@@ -0,0 +1,14 @@
+Element := struct {
+    width: int,
+    height: int, 
+
+    x: u16,
+    y: u16,
+
+    id: int,
+}
+
+create_element := fn(): Element {
+    return Element.(0, 0, 0, 0, 0)
+}
+

sysdata/libraries/horizon_api/src/frame.hb

@@ -0,0 +1,3 @@
+FrameID := struct {
+
+}

sysdata/libraries/horizon_api/src/lib.hb

@@ -1,49 +1,12 @@
-stn := @use("../../stn/src/lib.hb");
-.{string, memory, buffer, log} := stn
-
-render := @use("../../../libraries/render/src/lib.hb")
-
-input := @use("../../intouch/src/lib.hb")
-
-widgets := @use("widgets/widgets.hb")
-ui := @use("ui.hb")
-
 WindowID := struct {
 	host_id: int,
 	window_id: int,
 }
 
-VoidWindowID := WindowID.(0, 0)
+create_window := fn(): WindowID {
+	return WindowID.(1, 2)
+}
 
-create_window := fn(channel: int): ^render.Surface {
-	// get the horizon buffer
-	// request a new window and provide the callback buffer
-	// wait to recieve a message
-
-	windowing_system_buffer := buffer.search("XHorizon\0")
-	mem_buf := memory.request_page(1)
-
-	if windowing_system_buffer == 0 {
-		return @as(^render.Surface, idk)
-	} else {
-		// ! bad able, stop using string messages :ragey:
-		// msg := "\{01}\0"
-		// msg_length := 2
-
-		// @as(void, @eca(3, windowing_system_buffer, msg, msg_length))
-
-		x := 0
-		loop if x > 1000 break else x += 1
-
-		ret := buffer.recv([u8; 4096], windowing_system_buffer, mem_buf)
-		if ret == null {
-			log.info("No messages\0")
-		}
-
-		if *mem_buf == 0 {
-			log.info("No messages\0")
-		}
-
-		return @as(^render.Surface, idk)
-	}
+update_ui := fn(window_id: WindowID): void {
+	return
 }

sysdata/libraries/horizon_api/src/text.hb

@@ -0,0 +1,3 @@
+ui_lisp_text_example := "(text id_1)\0";
+
+

sysdata/libraries/horizon_api/src/ui.hb

@@ -1,47 +0,0 @@
-stn := @use("../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../libraries/render/src/lib.hb");
-.{Surface} := render;
-.{Font} := render.text
-
-UI := struct {raw: ^u8, raw_length: uint, is_dirty: bool, surface: Surface, // Each child has their WidgetType as their first byte
-// children: ^^u8,
-}
-
-render_ui := fn(surface: Surface, ui: UI): void {
-	if ui.is_dirty {
-		render.clear(ui.surface, render.black)
-		ui.is_dirty = false
-	}
-	pos := Vec2(uint).(0, 0)
-	render.put_surface(surface, ui.surface, pos, false)
-}
-
-sexpr_parser := fn(sexpr: ^u8): UI {
-	cursor := sexpr
-	paren_balance := 0
-	loop {
-		if *cursor == 0 {
-			if paren_balance != 0 {
-				log.error("Unbalanced Parens\0")
-			}
-			break
-		} else if *cursor == 40 {
-			log.info("Open paren\0")
-			paren_balance += 1
-		} else if *cursor == 41 {
-			log.info("Closed paren\0")
-			paren_balance -= 1
-		}
-
-		cursor += 1
-	}
-
-	length := string.length(sexpr)
-
-	ui_surface := render.new_surface(100, 100)
-
-	return UI.(sexpr, length, true, ui_surface)
-}

sysdata/libraries/horizon_api/src/widgets/image.hb

@@ -1,13 +0,0 @@
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface} := render
-
-Image := struct {
-	magic: uint,
-	is_dirty: bool,
-	surface: Surface,
-}
-
-image_from_surface := fn(surface: Surface): Image {
-	img := Image.(4, true, surface)
-	return img
-}

sysdata/libraries/horizon_api/src/widgets/label.hb

@@ -1,46 +0,0 @@
-stn := @use("../../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface, Color} := render;
-.{Font} := render.text
-
-Label := struct {
-	magic: uint,
-	is_dirty: bool,
-	surface: Surface,
-	text: ^u8,
-	text_length: uint,
-	bg: Color,
-	fg: Color,
-}
-
-set_label_text := fn(label: Label, text: ^u8): void {
-	text_length := string.length(text)
-
-	label.is_dirty = true
-	label.text = text
-	label.text_length = text_length
-}
-
-render_label_to_surface := fn(surface: Surface, label: Label, font: Font, pos: Vec2(uint)): void {
-	if label.is_dirty {
-		render.clear(label.surface, label.bg)
-		render.put_text(label.surface, font, .(0, 0), label.fg, label.text)
-	}
-	render.put_surface(surface, label.surface, pos, false)
-}
-
-new_label := fn(text: ^u8): Label {
-	text_surface := render.new_surface(1024, 20)
-	text_length := string.length(text)
-	label := Label.(3, true, text_surface, text, text_length, render.black, render.white)
-	return label
-}
-
-$set_color := fn(label: Label, bg: Color, fg: Color): void {
-	label.bg = bg
-	label.fg = fg
-	label.is_dirty = true
-}

sysdata/libraries/horizon_api/src/widgets/widget_types.hb

@@ -1,7 +0,0 @@
-NoWidget := 0
-
-VerticalWidgetType := 1
-HorizontalWidgetType := 2
-
-LabelWidgetType := 3
-ImageWidgetType := 4

sysdata/libraries/horizon_api/src/widgets/widgets.hb

@@ -1,36 +0,0 @@
-// Widget types
-
-// End types
-stn := @use("../../../../libraries/stn/src/lib.hb");
-.{string, log} := stn;
-.{Vec2} := stn.math
-
-render := @use("../../../../libraries/render/src/lib.hb");
-.{Surface} := render;
-.{Font} := render.text
-
-widget_types := @use("widget_types.hb")
-label := @use("label.hb")
-image := @use("image.hb")
-
-Size := struct {
-	min_width: int,
-	max_width: int,
-	min_height: int,
-	max_height: int,
-}
-
-Vertical := packed struct {
-	magic: uint,
-	// array of children, idk
-	// use a vec or linked list or whatever
-
-	children: ^^u8,
-}
-
-Horizontal := packed struct {
-	magic: uint,
-	// array of children, idk
-	// use a vec or linked list or whatever
-	children: ^^u8,
-}

sysdata/libraries/ignim/src/application.hb

@@ -1,21 +0,0 @@
-structures := @use("structures.hb")
-version := @use("version.hb")
-
-// Refer to here https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html
-ApplicationInfo := struct {
-	sType: int,
-	pNext: ^int,
-	application_name: ^u8,
-	application_version: int,
-	engine_name: ^u8,
-	engine_version: int,
-	api_version: int,
-}
-
-new_application_info := fn(app_name: ^u8, app_version: int, engine_name: ^u8, engine_version: int, api_version: int): ApplicationInfo {
-	app_info_type := structures.ApplicationInfoType
-
-	app_info := ApplicationInfo.(app_info_type, 0, app_name, app_version, engine_name, engine_version, api_version)
-
-	return app_info
-}

sysdata/libraries/ignim/src/errors.hb

@@ -1,14 +0,0 @@
-OutOfHostMemory := -1
-OutOfDeviceMemory := -2
-InitializationFailed := -3
-DeviceLost := -4
-MemoryMapFailed := -5
-
-LayerNotPresent := -6
-ExtensionNotPresent := -7
-FeatureNotPresent := -8
-IncompatibleDriver := -9
-TooManyObjects := -10
-FormatNotSupported := -11
-FragmentedPool := -12
-Unknown := -13

sysdata/libraries/ignim/src/extends.hb

@@ -1,10 +0,0 @@
-Extent3D := struct {
-	width: int,
-	height: int,
-	depth: int,
-}
-
-Extent2D := struct {
-	width: int,
-	height: int,
-}

sysdata/libraries/ignim/src/instance.hb

@@ -1,35 +0,0 @@
-application := @use("application.hb");
-.{ApplicationInfo} := application
-
-structures := @use("structures.hb")
-errors := @use("errors.hb")
-
-// https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html
-InstanceCreateInfo := struct {
-	sType: int,
-	pNext: int,
-	flags: int,
-	application_info: ^ApplicationInfo,
-	enabled_layer_count: int,
-	ppEnabledLayerNames: int,
-	enabled_extension_count: int,
-	ppEnabledExtensionNames: int,
-}
-
-new_create_info := fn(application_info: ^ApplicationInfo): InstanceCreateInfo {
-	create_info_type := structures.InstanceCreateInfoType
-	enabled_layer_count := 0
-
-	create_info := InstanceCreateInfo.(create_info_type, 0, 0, application_info, enabled_layer_count, 0, 0, 0)
-	return create_info
-}
-
-// TODO
-Instance := struct {inner: int}
-void_instance := fn(): Instance {
-	return Instance.(0)
-}
-
-create_instance := fn(create_info: ^InstanceCreateInfo, allocator_callback: int, new_obj: ^Instance): int {
-	return errors.IncompatibleDriver
-}

sysdata/libraries/ignim/src/lib.hb

@@ -1,17 +1,7 @@
-application := @use("application.hb")
+VK_VERSION_MAJOR := 1;
+VK_VERSION_MINOR := 0;
 
-results := @use("results.hb")
-errors := @use("errors.hb")
-
-offsets := @use("offset.hb")
-extends := @use("extends.hb")
-
-rect := @use("rect.hb")
-structures := @use("structures.hb")
-instance := @use("instance.hb")
-
-version := @use("version.hb")
-
-init_vulkan := fn(): int {
-	return errors.IncompatibleDriver
+init_vulkan := fn(): void {
+    
+    return
 }

sysdata/libraries/ignim/src/offset.hb

@@ -1,10 +0,0 @@
-Offset3D := struct {
-	x: int,
-	y: int,
-	z: int,
-}
-
-Offset2D := struct {
-	x: int,
-	y: int,
-}

sysdata/libraries/ignim/src/rect.hb

@@ -1,7 +0,0 @@
-offsets := @use("offset.hb")
-extends := @use("extends.hb")
-
-Rect2D := struct {
-	offset: offsets.Offset2D,
-	extent: extends.Extent2D,
-}

sysdata/libraries/ignim/src/results.hb

@@ -1,7 +0,0 @@
-// NonErrors
-Success := 0
-NotReady := 1
-Timeout := 2
-EventSet := 3
-EventReset := 4
-Incomplete := 5

sysdata/libraries/ignim/src/structures.hb

@@ -1,61 +0,0 @@
-ApplicationInfoType := 0
-InstanceCreateInfoType := 1
-DeviceQueueCreateInfo := 2
-DeviceCreateInfo := 3
-SubmitInfo := 4
-MemoryAllocateInfo := 5
-MappedMemoryRange := 6
-BindSparseInfo := 7
-
-FenceCreateInfo := 8
-SemaphoreCreateInfo := 9
-EventCreateInfo := 10
-QueryPoolCreateInfo := 11
-
-BufferCreateInfo := 12
-BufferViewCreateInfo := 13
-
-ImageCreateInfo := 14
-ImageViewCreateInfo := 15
-
-ShaderModuleCreateInfo := 16
-
-PipelineCacheCreateInfo := 17
-PipelineShaderStageCreateInfo := 18
-PipelineVertexInputStateCreateInfo := 19
-PipelineInputAssemblyStateCreateInfo := 20
-PipelineTessellationStateCreateInfo := 21
-PipelineViewportStateCreateInfo := 22
-PipelineRasterizationStateCreateInfo := 23
-PipelineMultisampleStateCreateInfo := 24
-PipelineDepthStencilStateCreateInfo := 25
-PipelineColorBlendStateCreateInfo := 26
-PipelineDynamicStateCreateInfo := 27
-
-GraphicsPipelineCreateInfo := 28
-ComputePipelineCreateInfo := 29
-PipelineLayoutCreateInfo := 30
-SamplerCreateInfo := 31
-
-DescriptorSetLayoutCreateInfo := 32
-DescriptorPoolCreateInfo := 33
-
-DescriptorSetAllocateInfo := 34
-WriteDescriptorSet := 35
-CopyDescriptorSet := 36
-FramebufferCreateInfo := 37
-
-RenderPassCreateInfo := 38
-CommandPoolCreateInfo := 39
-
-CommandBufferAllocateInfo := 40
-CommandBufferInheritanceInfo := 41
-CommandBufferBeginInfo := 42
-
-RenderPassBeginInfo := 43
-BufferMemoryBarrier := 44
-ImageMemoryBarrier := 45
-MemoryBarrier := 46
-
-LoaderInstanceCreateInfo := 47
-LoaderDeviceCreateInfo := 48

sysdata/libraries/ignim/src/version.hb

@@ -1,9 +0,0 @@
-ApiVersion1_0 := make_api_version(0, 1, 0, 0)
-
-make_version := fn(major: int, minor: int, patch: int): int {
-	return major << 22 | minor << 12 | patch
-}
-
-make_api_version := fn(variant: int, major: int, minor: int, patch: int): int {
-	return variant << 29 | major << 22 | minor << 12 | patch
-}

sysdata/libraries/intouch/README.md

@@ -1,20 +0,0 @@
-# intouch
-This library is exclusively focused on allowing your to get input regardless of which devices you have.
-
-Partially modeled after SDL.
-
-Current goals include
-- Interfaces
-    - PS/2
-- Device Types
-    - Keyboard
-    - Mouse
-
-Longer Term goals 
-- Interfaces
-    - USB
-    - USB-HID
-- Device Types
-    - Gamepads/controllers
-    - Drawing Tablets
-    - Microphones

sysdata/libraries/intouch/key_maps/ps2.map

@@ -1,2 +0,0 @@
-0x0D -> press Tab
-0xF0 0x0D -> release Tab

sysdata/libraries/intouch/src/events.hb

@@ -1,18 +0,0 @@
-keycodes := @use("keycodes.hb");
-.{KeyCode} := keycodes
-
-KeyEvent := packed struct {
-	up: bool,
-	just_triggered: bool,
-	key: KeyCode,
-}
-
-MouseEvent := packed struct {
-	x_change: i8,
-	y_change: i8,
-	left: bool,
-	middle: bool,
-	right: bool,
-}
-
-GamepadEvent := struct {}

sysdata/libraries/intouch/src/keycodes.hb

@@ -1,121 +0,0 @@
-/*
-Originally I was modelling this after the following(1). I have since changed my mind.
-I am now modelling it as I see fit. This is likely not the final version.
-
-1) https://www.libsdl.org/release/SDL-1.2.15/include/SDL_keysym.h
-*/
-
-KeyCode := u32
-
-// Typically this is not a keycode you will ever recieve.
-None := KeyCode.(0)
-
-Escape := KeyCode.(1)
-/* Alphabet keycodes */
-
-A := KeyCode.(2)
-B := KeyCode.(3)
-C := KeyCode.(4)
-D := KeyCode.(5)
-E := KeyCode.(6)
-F := KeyCode.(7)
-G := KeyCode.(8)
-H := KeyCode.(9)
-I := KeyCode.(10)
-J := KeyCode.(11)
-K := KeyCode.(12)
-L := KeyCode.(13)
-M := KeyCode.(14)
-N := KeyCode.(15)
-O := KeyCode.(16)
-P := KeyCode.(17)
-Q := KeyCode.(18)
-R := KeyCode.(19)
-S := KeyCode.(20)
-T := KeyCode.(21)
-U := KeyCode.(22)
-V := KeyCode.(23)
-W := KeyCode.(24)
-X := KeyCode.(25)
-Y := KeyCode.(26)
-Z := KeyCode.(27)
-
-/* Numeric keycodes*/
-
-Number0 := KeyCode.(28)
-Number1 := KeyCode.(29)
-Number2 := KeyCode.(30)
-Number3 := KeyCode.(31)
-Number4 := KeyCode.(32)
-Number5 := KeyCode.(33)
-Number6 := KeyCode.(34)
-Number7 := KeyCode.(35)
-Number8 := KeyCode.(36)
-Number9 := KeyCode.(37)
-
-KeypadNumber0 := KeyCode.(38)
-KeypadNumber1 := KeyCode.(39)
-KeypadNumber2 := KeyCode.(40)
-KeypadNumber3 := KeyCode.(41)
-KeypadNumber4 := KeyCode.(42)
-KeypadNumber5 := KeyCode.(43)
-KeypadNumber6 := KeyCode.(44)
-KeypadNumber7 := KeyCode.(45)
-KeypadNumber8 := KeyCode.(46)
-KeypadNumber9 := KeyCode.(47)
-
-KeypadPeriod := KeyCode.(48)
-KeypadDivide := KeyCode.(49)
-KeypadMultiply := KeyCode.(50)
-KeypadMinus := KeyCode.(51)
-KeypadPlus := KeyCode.(52)
-KeypadEnter := KeyCode.(53)
-KeypadEquals := KeyCode.(54)
-
-Delete := KeyCode.(55)
-/* Locking Keys */
-NumLock := KeyCode.(56)
-CapsLock := KeyCode.(57)
-ScrollLock := KeyCode.(58)
-
-/* "Alt Gr" key */
-Mode := KeyCode.(59)
-
-/* Multi-key compose key */
-Compose := KeyCode.(60)
-
-LeftAlt := KeyCode.(61)
-LeftControl := KeyCode.(62)
-LeftMeta := KeyCode.(63)
-LeftShift := KeyCode.(64)
-/* Left "Windows" key */
-LeftSuper := KeyCode.(65)
-
-RightAlt := KeyCode.(66)
-RightControl := KeyCode.(67)
-RightMeta := KeyCode.(68)
-RightShift := KeyCode.(69)
-/* Right "Windows" key */
-RightSuper := KeyCode.(70)
-
-/*
-    This block of any triggers on any press of any of the keys.
-    Typically this is the event to care about.
-*/
-AnyNumber0 := KeyCode.(71)
-AnyNumber1 := KeyCode.(72)
-AnyNumber2 := KeyCode.(73)
-AnyNumber3 := KeyCode.(74)
-AnyNumber4 := KeyCode.(75)
-AnyNumber5 := KeyCode.(76)
-AnyNumber6 := KeyCode.(77)
-AnyNumber7 := KeyCode.(78)
-AnyNumber8 := KeyCode.(79)
-AnyNumber9 := KeyCode.(80)
-
-AnyAlt := KeyCode.(81)
-AnyControl := KeyCode.(82)
-AnyMeta := KeyCode.(83)
-AnyShift := KeyCode.(84)
-/* Any "Windows" key */
-AnySuper := KeyCode.(85)

sysdata/libraries/intouch/src/lib.hb

@@ -1,36 +0,0 @@
-stn := @use("../../stn/src/lib.hb");
-.{log, buffer, memory} := stn
-keycodes := @use("keycodes.hb")
-
-events := @use("events.hb");
-.{KeyEvent, MouseEvent} := events
-
-recieve_key_event := fn(): ?KeyEvent {
-	kevent := KeyEvent.(false, false, 0)
-
-	buf_id := buffer.search("PS/2 Keyboard\0")
-
-	// Read out of the Keyboard buffer here
-	buffer.recv(KeyEvent, buf_id, &kevent)
-
-	if kevent.just_triggered {
-		return kevent
-	}
-
-	return null
-}
-
-recieve_mouse_event := fn(): ?MouseEvent {
-	mevent := MouseEvent.(0, 0, false, false, false)
-
-	buf_id := buffer.search("PS/2 Mouse\0")
-
-	// Read out of the Mouse buffer here
-	buffer.recv(MouseEvent, buf_id, &mevent)
-
-	if mevent.x_change != 0 | mevent.y_change != 0 | mevent.left | mevent.middle | mevent.right {
-		return mevent
-	}
-
-	return null
-}

sysdata/libraries/pci/README.md

@@ -1 +0,0 @@
-# pci

sysdata/libraries/pci/src/lib.hb

@@ -1,93 +0,0 @@
-.{string, memory, buffer, log} := @use("../../stn/src/lib.hb")
-
-PCIAddress := struct {
-	bus: u8,
-	device: u8,
-	function: u8,
-}
-
-PCI_ID := struct {
-	vendor: u16,
-	device: u16,
-	inner: int,
-}
-
-get_ids := fn(bus: u8, device: u8, function: u8): PCI_ID {
-	res := config_read32(bus, device, function, 0)
-	dev_id := res >> 16
-	dev_id &= 0xFFFF
-
-	vnd_id := res & 0xFFFF
-	return PCI_ID.(dev_id, vnd_id, 0)
-}
-
-PciDeviceInfo := struct {
-	header_type: u8,
-	device: u8,
-	bus: u8,
-	device_id: PCI_ID,
-	class: u16,
-	rev_id: u8,
-}
-
-calculate_address := fn(bus: u8, device: u8, function: u8, offset: u8): int {
-	address := bus << 16
-	address |= device << 11
-	address |= function << 8
-	address |= offset & 0xFC
-	address |= 0x80000000
-	return address
-}
-
-get_header_type := fn(bus: u8, device: u8, function: u8): u8 {
-	res := config_read32(bus, device, function, 0xC)
-	ret := res >> 16
-	ret &= 0xFF
-
-	return ret
-}
-
-check_device := fn(bus: u8, device: u8): PciDeviceInfo {
-	pci_id := get_ids(bus, device, 0)
-
-	if pci_id.vendor == 0xFFFF {
-		log.warn(":|\0")
-	} else {
-		log.info(":)\0")
-	}
-	address := calculate_address(bus, device, 0, 0x8)
-	reg2 := config_read32(bus, device, 0, 0x8)
-
-	class := reg2 >> 16 & 0xFFFF
-
-	header_type := get_header_type(bus, device, 0)
-
-	rev_id := reg2 & 0xFF
-	return PciDeviceInfo.(header_type, device, bus, pci_id, class, rev_id)
-}
-
-find_device := fn(vendor_id: int, device_id: int, pci_address: PCIAddress): PCI_ID {
-	pci_id := get_ids(0, 2, 0)
-
-	return pci_id
-}
-
-scan_bus := fn(): void {
-}
-
-config_read32 := fn(bus: u32, device: u32, func: u32, offset: u32): u32 {
-	// construct address param
-	offset_and := offset & 0xFC
-
-	address := bus << 16
-	address |= device << 11
-	address |= func << 8
-	address |= offset_and
-	address |= 0x80000000
-
-	// write address
-	memory.outl(0xCF8, address)
-
-	// read data
-	return memory.inl(0xCFC)
-}

sysdata/libraries/render/TODO.md

@@ -1,27 +0,0 @@
-# Images
-- Animation
-
-# API
-- Colour operations:
-    - Alpha Composite
-    - Invert
-- Surface Operations:
-    - FlipH
-    - Resize
-    - Wrap the colour operations
-    - Tile
-    - Gradient overlay
-- Draw operations:
-    - Curve raster algorithm
-    - VGA font fast blit
-    - Polygon
-    - Rounded rects
-
-# Backend
-- SVGA Driver
-- Support whatever vulkan stuff able is cooking
-
-# Bits and bobs on the table
-- Funny 3D Renderer
-- stn.memory.swap & kernel message
-- Make memory.{copy, set} smart

sysdata/libraries/render/src/image/bmp.hb

@@ -1,49 +0,0 @@
-.{Color, Surface, new_surface, put_surface} := @use("../lib.hb");
-.{log} := @use("../../../stn/src/lib.hb")
-
-BitmapFileHeader := packed struct {
-	magic: u16,
-	size: u32,
-	reserved_1: u16,
-	reserved_2: u16,
-	offset: u32,
-}
-
-BitmapInfoHeader := packed struct {
-	size: u32,
-	width: i32,
-	height: i32,
-	planes: u16,
-	bits: u16,
-	compression: u32,
-	image_size: u32,
-	x_resolution: i32,
-	y_resolution: i32,
-	n_colours: u32,
-	important_colours: u32,
-}
-
-BitmapColorHeader := packed struct {
-	red_mask: u32,
-	green_mask: u32,
-	blue_mask: u32,
-	alpha_mask: u32,
-	color_space_type: u32,
-	unused: u32,
-}
-
-from := fn(bmp: ^u8): ?Surface {
-	file_header := @as(^BitmapFileHeader, @bitcast(bmp))
-	info_header := @as(^BitmapInfoHeader, @bitcast(bmp + @sizeof(BitmapFileHeader)))
-
-	if file_header.magic != 0x4D42 | info_header.width == 0 | info_header.height == 0 {
-		log.error("Invalid BMP image.\0")
-		return null
-	}
-
-	lhs := Surface.(@bitcast(bmp + file_header.offset), info_header.width, info_header.height, info_header.width * info_header.height)
-	rhs := new_surface(info_header.width, info_header.height)
-	put_surface(rhs, lhs, .(0, 0), true)
-
-	return rhs
-}

sysdata/libraries/render/src/image/lib.hb

@@ -1,31 +0,0 @@
-.{log} := @use("../../../stn/src/lib.hb");
-.{Surface} := @use("../lib.hb")
-bmp := @use("bmp.hb")
-qoi := @use("qoi.hb")
-$BMP := 0x4D42
-$QOI := 0x66696F71
-
-get_format := fn(file: ^u8): ?uint {
-	if *@as(^u16, @bitcast(file)) == BMP {
-		return BMP
-	} else if *@as(^u32, @bitcast(file)) == QOI {
-		return QOI
-	} else {
-		return null
-	}
-}
-
-from := fn(file: ^u8): ?Surface {
-	format := get_format(file)
-
-	if format == null {
-		log.error("Could not detect image format.\0")
-		return null
-	} else if format == BMP {
-		return bmp.from(file)
-	} else if format == QOI {
-		return qoi.from(file)
-	}
-
-	return null
-}

sysdata/libraries/render/src/image/qoi.hb

@@ -1,101 +0,0 @@
-.{Color, Surface, new_surface} := @use("../lib.hb");
-.{log} := @use("../../../stn/src/lib.hb")
-
-/* source:
-   https://github.com/phoboslab/qoi/blob/master/qoi.h */
-
-$QOI_SRGB := 0
-$QOI_LINEAR := 1
-$QOI_OP_INDEX := 0x0
-$QOI_OP_DIFF := 0x40
-$QOI_OP_LUMA := 0x80
-$QOI_OP_RUN := 0xC0
-$QOI_OP_RGB := 0xFE
-$QOI_OP_RGBA := 0xFF
-$QOI_MASK_2 := 0xC0
-$QOI_COLOR_HASH := fn(c: Color): u8 {
-	return (c.r * 3 + c.g * 5 + c.b * 7 + c.a * 11) % 64
-}
-$QOI_MAGIC := 0x716F6966
-$QOI_PIXELS_MAX := 400000000
-
-QuiteOkayHeader := packed struct {
-	magic: u32,
-	width: u32,
-	height: u32,
-	channels: u8,
-	colorspace: u8,
-}
-
-be_to_le := fn(big: u32): u32 {
-	return big >> 24 | big >> 8 & 0xFF00 | big << 8 & 0xFF0000 | big << 24
-}
-
-from := fn(qoi: ^u8): ?Surface {
-	header := @as(^QuiteOkayHeader, @bitcast(qoi))
-
-	qoi += @sizeof(QuiteOkayHeader)
-
-	width := be_to_le(header.width)
-	height := be_to_le(header.height)
-
-	if be_to_le(header.magic) != QOI_MAGIC | width == 0 | height == 0 | header.channels < 3 | header.channels > 4 {
-		log.error("Invalid QOI image.\0")
-		return null
-	}
-
-	surface := new_surface(width, height)
-	index := @as([Color; 64], idk)
-
-	run := 0
-	px := Color.(0, 0, 0, 255)
-	px_pos := 0
-
-	total_pixels := width * height
-
-	loop if px_pos >= total_pixels break else {
-		if run > 0 {
-			run -= 1
-		} else {
-			b1 := *qoi
-			qoi += 1
-
-			if b1 == QOI_OP_RGB {
-				px.r = *qoi
-				px.g = *(qoi + 1)
-				px.b = *(qoi + 2)
-				qoi += 3
-			} else if b1 == QOI_OP_RGBA {
-				px.r = *qoi
-				px.g = *(qoi + 1)
-				px.b = *(qoi + 2)
-				px.a = *(qoi + 3)
-				qoi += 4
-			} else if (b1 & QOI_MASK_2) == QOI_OP_INDEX {
-				px = index[b1 & 0x3F]
-			} else if (b1 & QOI_MASK_2) == QOI_OP_DIFF {
-				px.r = px.r + (b1 >> 4 & 0x3) - 2 & 0xFF
-				px.g = px.g + (b1 >> 2 & 0x3) - 2 & 0xFF
-				px.b = px.b + (b1 & 0x3) - 2 & 0xFF
-			} else if (b1 & QOI_MASK_2) == QOI_OP_LUMA {
-				b2 := *qoi
-				vg := (b1 & 0x3F) - 32
-
-				px.r = px.r + vg - 8 + (b2 >> 4 & 0xF) & 0xFF
-				px.g = px.g + vg & 0xFF
-				px.b = px.b + vg - 8 + (b2 & 0xF) & 0xFF
-				qoi += 1
-			} else if (b1 & QOI_MASK_2) == QOI_OP_RUN {
-				run = b1 & 0x3F
-			}
-
-			index[QOI_COLOR_HASH(px)] = px
-		};
-
-		*(surface.buf + px_pos) = px
-
-		px_pos += 1
-	}
-
-	return surface
-}

sysdata/libraries/render/src/lib.hb

@@ -1,57 +1,47 @@
-software := @use("software.hb")
-image := @use("image/lib.hb")
-text := @use("text.hb")
+svga := @use("rel:svga.hb")
+software := @use("rel:software.hb")
 
 // default mode
 mode := software
 
 init := mode.init
 doublebuffer := mode.doublebuffer
-Surface := mode.Surface
-new_surface := mode.new_surface
-surface_from_ptr := mode.surface_from_ptr
-clone_surface := mode.clone_surface
-free_surface := mode.free_surface
-index := mode.index
-indexptr := mode.indexptr
 
 // Colours
-Color := packed struct {b: u8, g: u8, r: u8, a: u8}
-$white := Color.(255, 255, 255, 255)
-$black := Color.(0, 0, 0, 255)
-$gray := Color.(127, 127, 127, 255)
-$red := Color.(0, 0, 205, 255)
-$green := Color.(0, 205, 0, 255)
-$yellow := Color.(0, 205, 205, 255)
-$blue := Color.(205, 0, 0, 255)
-$magenta := Color.(205, 0, 205, 255)
-$cyan := Color.(205, 205, 0, 255)
-$light_gray := Color.(229, 229, 229, 255)
-$light_red := Color.(0, 0, 255, 255)
-$light_green := Color.(0, 255, 0, 255)
-$light_yellow := Color.(0, 255, 255, 255)
-$light_blue := Color.(255, 0, 0, 255)
-$light_magenta := Color.(255, 0, 255, 255)
-$light_cyan := Color.(255, 255, 0, 255)
+Color := mode.Color
+white := mode.white
+black := mode.black
+gray := mode.gray
+red := mode.red
+green := mode.green
+yellow := mode.yellow
+blue := mode.blue
+magenta := mode.magenta
+cyan := mode.cyan
+light_gray := mode.light_gray
+light_red := mode.light_red
+light_green := mode.light_green
+light_yellow := mode.light_yellow
+light_blue := mode.light_blue
+light_magenta := mode.light_magenta
+light_cyan := mode.light_cyan
 
 // Drawing
 put_pixel := mode.put_pixel
 put_rect := mode.put_rect
 put_filled_rect := mode.put_filled_rect
-put_trirect := mode.put_trirect
-put_circle := mode.put_circle
-put_filled_circle := mode.put_filled_circle
-put_textured_circle := mode.put_textured_circle
 put_line := mode.put_line
-put_vline := mode.put_vline
-put_hline := mode.put_hline
 clear := mode.clear
-put_surface := mode.put_surface
-put_text := mode.put_text
-// thanks peony for these three!
-//put_trirect := mode.put_trirect
-//put_vline := mode.put_vline
-//put_hline := mode.put_hline
 
 // Display
-sync := mode.sync
+width := mode.width
+height := mode.height
+dimensions := mode.dimensions
+set_height := mode.set_height
+set_width := mode.set_width
+set_dimensions := mode.set_dimensions
+sync := mode.sync
+
+// Math
+UVec2 := struct {x: uint, y: uint}
+IVec2 := struct {x: int, y: int}