Refactor

crates/os-std/src/lib.rs

@@ -1,12 +1,34 @@
 #![no_std]
 
-mod prelude;
+extern crate alloc;
+
+pub mod prelude;
 
 pub use shared::syscall;
 
 #[macro_export]
 macro_rules! custom_std_setup {
     () => {
+        use $crate::prelude::*;
+
+        extern crate alloc;
+
+        struct GlobalAllocator;
+
+        #[global_allocator]
+        static GLOBAL_ALLOCATOR: GlobalAllocator = GlobalAllocator;
+
+        unsafe impl core::alloc::GlobalAlloc for GlobalAllocator {
+            unsafe fn alloc(&self, layout: core::alloc::Layout) -> *mut u8 {
+                syscall::write_string_temp("Alloc user called");
+                $crate::syscall::alloc(layout)
+            }
+
+            unsafe fn dealloc(&self, ptr: *mut u8, layout: core::alloc::Layout) {
+                $crate::syscall::dealloc(ptr, layout)
+            }
+        }
+
         #[panic_handler]
         fn panic(_panic_info: &core::panic::PanicInfo) -> ! {
             // TODO print
@@ -19,3 +41,21 @@ macro_rules! custom_std_setup {
         }
     };
 }
+
+#[macro_export]
+macro_rules! print {
+    ($($args:expr),*) => {
+        $crate::syscall::write_string_temp(&format!($($args),*))
+    };
+}
+#[macro_export]
+macro_rules! println {
+    () => {
+        // $crate::print!("");
+        $crate::print!("\n\r");
+    };
+    ($($args:expr),*) => {
+        $crate::print!($($args),*);
+        $crate::println!();
+    };
+}

crates/os-std/src/prelude.rs

@@ -1 +1,5 @@
-
+pub use crate::print;
+pub use crate::println;
+pub use alloc::format;
+pub use alloc::string::String;
+pub use alloc::vec;

crates/shared/src/syscall.rs

@@ -1,7 +1,9 @@
-use core::time::Duration;
+use core::{alloc::Layout, time::Duration};
 
 #[repr(u64)]
 pub enum SysCall {
+    Alloc = 40,
+    Dealloc = 41,
     Exit = 60,
     NanoSleep = 101,
     WriteIntTemp = 998,
@@ -12,6 +14,8 @@ pub enum SysCall {
 impl From<u64> for SysCall {
     fn from(value: u64) -> Self {
         match value {
+            40 => SysCall::Alloc,
+            41 => SysCall::Dealloc,
             60 => SysCall::Exit,
             101 => SysCall::NanoSleep,
             998 => SysCall::WriteIntTemp,
@@ -90,7 +94,7 @@ pub fn sleep(duration: Duration) {
     }
 }
 
-pub fn write_string_temp(content: &'static str) {
+pub fn write_string_temp(content: &str) {
     unsafe {
         syscall!(
             SysCall::WriteTemp,
@@ -104,3 +108,19 @@ pub fn write_int_temp(content: u64) {
         syscall!(SysCall::WriteIntTemp, content);
     }
 }
+
+pub fn alloc(layout: Layout) -> *mut u8 {
+    unsafe {
+        let size = layout.size();
+        let align = layout.align();
+        let (ptr, ..) = syscall!(SysCall::Alloc, size as u64, align as u64);
+        ptr as *mut u8
+    }
+}
+pub fn dealloc(ptr: *mut u8, layout: core::alloc::Layout) {
+    unsafe {
+        let size = layout.size();
+        let align = layout.align();
+        syscall!(SysCall::Dealloc, ptr as u64, size as u64, align as u64);
+    }
+}