commands WIP

Author: phcoder

src/grub_lib.rs

@@ -1,18 +1,56 @@
+#![feature(extern_types)]
+
 extern crate alloc;
 
+use alloc::vec::Vec;
+use alloc::vec;
+use alloc::string::String;
 use core::alloc::{GlobalAlloc, Layout};
 use core::ffi::c_char;
+use core::ffi::c_int;
+use core::ffi::c_void;
 
 use alloc::ffi::CString;
+use core::ffi::CStr;
 use core::panic::PanicInfo;
 
 extern "C" {
     static grub_xputs: extern "C" fn(stri: *const c_char);
     pub fn grub_abort();
     pub fn grub_malloc(sz: usize) -> *mut u8;
     pub fn grub_free(ptr: *mut u8);
+    pub fn grub_register_command_prio (name: *const c_char,
+				       func: fn (cmd: *const GrubCommand,
+						 argc: c_int, argv: *const *const c_char) ->err_t,
+				       summary: *const c_char,
+				       description: *const c_char,
+				       prio: c_int) -> *mut GrubCommand;
+    pub fn grub_strlen (s: *const c_char) -> usize;
+    pub fn grub_unregister_command (cmd: *const GrubCommand);
+}
+
+#[no_mangle]
+pub extern "C" fn strlen(s: *const c_char) -> usize {
+    return unsafe { grub_strlen(s) }; 
+}
+
+
+// TODO: Use code generation?
+#[repr(C)]
+pub struct GrubCommand {
+    next: *mut GrubCommand,
+    prev: *mut *mut GrubCommand,
+    name: *const c_char,
+    prio: c_int,
+    func: *const c_void,
+    flags: u32,
+    summary: *const c_char,
+    description: *const c_char,
+    data: *const c_void,
 }
 
+pub type GrubCommandPtr = *const GrubCommand;
+pub type err_t = u32;
 
 struct GrubAllocator;
 
@@ -44,3 +82,30 @@ fn panic(info: &PanicInfo) -> ! {
     }
     loop{}
 }
+
+fn cmd_callback (cmd: *const GrubCommand,
+		 argc: c_int, argv: *const *const c_char) -> err_t {
+    let mut argv_vec: Vec<&str> = vec![];
+    for i in 0..argc {
+	argv_vec.push(unsafe { CStr::from_ptr(*argv.add(i as usize)) }.to_str().unwrap());
+    }
+
+    return unsafe{(*((*cmd).data as *const fn (argc: usize, argv: &[&str]) -> err_t))} (argc as usize, &argv_vec);
+}
+
+pub fn register_command (name: &str, cb: fn (argc: usize, argv: &[&str]) -> err_t,
+			 summary: &str, description: &str) -> GrubCommandPtr {
+    unsafe {
+	let cmd = grub_register_command_prio (CString::new(name).unwrap().as_ptr(),
+					      cmd_callback,
+					      CString::new(summary).unwrap().as_ptr(),
+					      CString::new(description).unwrap().as_ptr(),
+					      0);
+	(*cmd).data = cb as *mut c_void;
+	return cmd;
+    }
+}
+
+pub fn unregister_command (cmd: GrubCommandPtr) {
+    unsafe { grub_unregister_command(cmd); }
+}

src/lib.rs

@@ -1,5 +1,6 @@
 #![no_std]
 #![no_main]
+#![feature(extern_types)]
 
 mod grub_lib;
 
@@ -11,7 +12,25 @@ pub static GRUB_MODNAME: [u8; 11] = [b'r', b'u', b's', b't', b'_', b'h', b'e',
 #[no_mangle]
 pub static GRUB_LICENSE: [u8; 15] = [b'L', b'I', b'C', b'E', b'N', b'S', b'E', b'=', b'G', b'P', b'L', b'v', b'3', b'+', b'\0'];
 
+static mut cmd: grub_lib::GrubCommandPtr = core::ptr::null();
+
+fn rust_hello (_argc: usize, _argv: &[&str]) -> grub_lib::err_t {
+    grub_lib::xputs("Hello, world\n");
+    return 0;
+}
+
 #[no_mangle]
 pub extern "C" fn grub_mod_init() {
     grub_lib::xputs("Hello");
+    unsafe {
+	cmd = grub_lib::register_command ("rust_hello", rust_hello,
+					  "Rust hello", "Say hello from Rust.");
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn grub_mod_fini() {
+    unsafe {
+	grub_lib::unregister_command (cmd);
+    }
 }