feat: add remaining console.obj functions (closes #1)

Cargo.toml

@@ -21,3 +21,6 @@ path = "examples/dark.rs"
 [profile.release]
 opt-level = "z"
 lto = "thin"
+
+[[example]]
+name = "fs_demo"

examples/fs_demo.rs

@@ -0,0 +1,12 @@
+#![no_std]
+#![no_main]
+
+use kos::fs::fs_read;
+
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+    let path = c"/rd/1/readme.txt";
+    let mut buf = [0u8; 512];
+    let (_status, _bytes) = fs_read(path, &mut buf);
+    loop {}
+}

src/dll/console.rs

@@ -6,10 +6,23 @@ pub struct Console {
     con_init: extern "stdcall" fn(u32, u32, u32, u32, *const u8),
     con_write_string: extern "stdcall" fn(*const u8, u32),
     con_exit: extern "stdcall" fn(bool),
+    con_set_title: extern "stdcall" fn(*const u8),
+    con_get_flags: extern "stdcall" fn() -> u32,
+    con_set_flags: extern "stdcall" fn(u32) -> u32,
+    con_get_font_height: extern "stdcall" fn() -> u32,
+    con_get_cursor_height: extern "stdcall" fn() -> u32,
+    con_set_cursor_height: extern "stdcall" fn(u32) -> u32,
+    con_getch: extern "stdcall" fn() -> u32,
+    con_getch2: extern "stdcall" fn() -> u16,
+    con_kbhit: extern "stdcall" fn() -> u32,
+    con_gets: extern "stdcall" fn(*mut u8, u32) -> *mut u8,
+    con_cls: extern "stdcall" fn(),
+    con_get_cursor_pos: extern "stdcall" fn(*mut u32, *mut u32),
+    con_set_cursor_pos: extern "stdcall" fn(u32, u32),
 }
 
 impl Console {
-    pub fn import(path: Option<&CStr>) -> Result<Self, &str> {
+    pub fn import(path: Option<&CStr>) -> Result<Self, &'static str> {
         let lib = DLL::load_dll(path.unwrap_or(c"/sys/lib/console.obj"));
         match lib {
             Err(e) => return Err(e),
@@ -18,6 +31,19 @@ impl Console {
                     con_init: transmute(dll.get_func(c"con_init").ok().unwrap()),
                     con_write_string: transmute(dll.get_func(c"con_write_string").ok().unwrap()),
                     con_exit: transmute(dll.get_func(c"con_exit").ok().unwrap()),
+                    con_set_title: transmute(dll.get_func(c"con_set_title").ok().unwrap()),
+                    con_get_flags: transmute(dll.get_func(c"con_get_flags").ok().unwrap()),
+                    con_set_flags: transmute(dll.get_func(c"con_set_flags").ok().unwrap()),
+                    con_get_font_height: transmute(dll.get_func(c"con_get_font_height").ok().unwrap()),
+                    con_get_cursor_height: transmute(dll.get_func(c"con_get_cursor_height").ok().unwrap()),
+                    con_set_cursor_height: transmute(dll.get_func(c"con_set_cursor_height").ok().unwrap()),
+                    con_getch: transmute(dll.get_func(c"con_getch").ok().unwrap()),
+                    con_getch2: transmute(dll.get_func(c"con_getch2").ok().unwrap()),
+                    con_kbhit: transmute(dll.get_func(c"con_kbhit").ok().unwrap()),
+                    con_gets: transmute(dll.get_func(c"con_gets").ok().unwrap()),
+                    con_cls: transmute(dll.get_func(c"con_cls").ok().unwrap()),
+                    con_get_cursor_pos: transmute(dll.get_func(c"con_get_cursor_pos").ok().unwrap()),
+                    con_set_cursor_pos: transmute(dll.get_func(c"con_set_cursor_pos").ok().unwrap()),
                 })
             },
         }
@@ -34,4 +60,60 @@ impl Console {
     pub fn exit(self, close_window: bool) {
         (self.con_exit)(close_window);
     }
+
+    pub fn set_title(&self, title: &CStr) {
+        (self.con_set_title)(title.as_ptr() as *const u8);
+    }
+
+    pub fn get_flags(&self) -> u32 {
+        (self.con_get_flags)()
+    }
+
+    pub fn set_flags(&self, flags: u32) -> u32 {
+        (self.con_set_flags)(flags)
+    }
+
+    pub fn get_font_height(&self) -> u32 {
+        (self.con_get_font_height)()
+    }
+
+    pub fn get_cursor_height(&self) -> u32 {
+        (self.con_get_cursor_height)()
+    }
+
+    pub fn set_cursor_height(&self, height: u32) -> u32 {
+        (self.con_set_cursor_height)(height)
+    }
+
+    pub fn getch(&self) -> u32 {
+        (self.con_getch)()
+    }
+
+    pub fn getch2(&self) -> u16 {
+        (self.con_getch2)()
+    }
+
+    pub fn kbhit(&self) -> u32 {
+        (self.con_kbhit)()
+    }
+
+    pub fn gets<'a>(&self, buf: &'a mut [u8]) -> Option<&'a [u8]> {
+        let ptr = (self.con_gets)(buf.as_mut_ptr(), buf.len() as u32);
+        if ptr.is_null() { None } else { Some(buf) }
+    }
+
+    pub fn cls(&self) {
+        (self.con_cls)();
+    }
+
+    pub fn get_cursor_pos(&self) -> (u32, u32) {
+        let mut x = 0u32;
+        let mut y = 0u32;
+        (self.con_get_cursor_pos)(&mut x, &mut y);
+        (x, y)
+    }
+
+    pub fn set_cursor_pos(&self, x: u32, y: u32) {
+        (self.con_set_cursor_pos)(x, y);
+    }
 }

src/fs.rs

@@ -0,0 +1,14 @@
+use core::ffi::CStr;
+use crate::sys::{syscall_fs, FileSystemRequest};
+
+pub fn fs_read(path: &CStr, buf: &mut [u8]) -> (u32, u32) {
+    let req = FileSystemRequest {
+        operation:   0,
+        offset_low:  0,
+        offset_high: 0,
+        byte_count:  buf.len() as u32,
+        buffer:      buf.as_mut_ptr() as u32,
+        path:        path.as_ptr() as u32,
+    };
+    unsafe { syscall_fs(&req) }
+}

src/lib.rs

@@ -6,6 +6,7 @@ mod nanolibc;
 pub mod allocation;
 pub mod dll;
 pub mod sys;
+pub mod fs;
 
 pub use modules::*;
 

src/nanolibc.rs

@@ -31,12 +31,3 @@ pub unsafe extern "C" fn memcmp(s1: *mut u8, s2: *const u8, n: usize) -> i32 {
 
     0
 }
-
-#[no_mangle]
-pub unsafe extern "C" fn strlen(str: *mut u8) -> usize {
-    let mut len = 0usize;
-    loop {
-        if *str.add(len) == 0 { return len; }
-        len += 1;
-    }
-}

src/sys.rs

@@ -68,3 +68,26 @@ extern "C" {
     #[link_name = "_load_dll"]
     pub fn load_dll(name: *const u8) -> *const u32;
 }
+
+#[repr(C)]
+pub struct FileSystemRequest {
+    pub operation:    u32,
+    pub offset_low:   u32,
+    pub offset_high:  u32,
+    pub byte_count:   u32,
+    pub buffer:       u32,
+    pub path:         u32,
+}
+
+pub unsafe fn syscall_fs(req: *const FileSystemRequest) -> (u32, u32) {
+    let eax_result: u32;
+    let ebx_result: u32;
+    core::arch::asm!(
+        "int 0x40",
+        inout("eax") 70u32 => eax_result,
+        in("ebx") req,
+        out("ebx") ebx_result,
+        options(nostack)
+    );
+    (eax_result, ebx_result)
+}