[library/std pal args]: implemented args for safaos

Author: safiworks

library/std/src/sys/pal/safaos/args.rs

@@ -1,36 +1,87 @@
+use core::cell::SyncUnsafeCell;
+use core::ptr::NonNull;
+
 use crate::ffi::OsString;
 use crate::fmt;
+use crate::mem::MaybeUninit;
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct RawArgs {
+    pub(super) args: NonNull<[(NonNull<u8>, usize)]>,
+}
+
+impl RawArgs {
+    fn len(&self) -> usize {
+        unsafe { (*self.args.as_ptr()).len() }
+    }
 
-pub struct Args {}
+    fn get(&self, index: usize) -> Option<&'static str> {
+        unsafe {
+            let args = &*self.args.as_ptr();
+            let (ptr, len) = args.get(index)?;
+            Some(core::str::from_utf8_unchecked(core::slice::from_raw_parts(ptr.as_ptr(), *len)))
+        }
+    }
+}
+
+unsafe impl Sync for RawArgs {}
+
+pub(super) static RAW_ARGS: SyncUnsafeCell<MaybeUninit<Option<RawArgs>>> =
+    SyncUnsafeCell::new(MaybeUninit::uninit());
+pub struct Args {
+    raw_args: Option<RawArgs>,
+    index: usize,
+}
 
 pub fn args() -> Args {
-    Args {}
+    Args { raw_args: unsafe { (*RAW_ARGS.get()).assume_init() }, index: 0 }
 }
 
 impl fmt::Debug for Args {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_list().finish()
+        let mut list = f.debug_list();
+        let len = self.len();
+        for i in 0..len {
+            // safe because index is always in len and raw_args is initialized (otherwise len is going to be 0)
+            let arg = unsafe { self.raw_args.unwrap_unchecked().get(i).unwrap_unchecked() };
+            list.entry(&arg);
+        }
+        list.finish()
     }
 }
 
 impl Iterator for Args {
     type Item = OsString;
     fn next(&mut self) -> Option<OsString> {
-        None
+        if self.index >= self.len() {
+            return None;
+        }
+        // it is gruanted that the raw_args is initialized if len > 0
+        let raw_args = unsafe { self.raw_args.unwrap_unchecked() };
+        let results = raw_args.get(self.index).map(|arg| OsString::from(arg));
+        self.index += 1;
+        results
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(0))
+        let len = self.len();
+
+        if len == 0 {
+            (0, Some(0))
+        } else {
+            let left = len - self.index;
+            (left, Some(left))
+        }
     }
 }
 
 impl ExactSizeIterator for Args {
     fn len(&self) -> usize {
-        0
+        self.raw_args.map(|s| s.len()).unwrap_or(0)
     }
 }
 
 impl DoubleEndedIterator for Args {
     fn next_back(&mut self) -> Option<OsString> {
-        None
+        todo!("next_back on Args is not implemented yet")
     }
 }

library/std/src/sys/pal/safaos/start.rs

@@ -1,13 +1,35 @@
-use crate::ffi::{c_char, c_int};
-use crate::ptr;
+use core::ptr::NonNull;
+
+use super::args::RAW_ARGS;
+use super::args::RawArgs;
+use super::os::exit;
+use crate::mem::MaybeUninit;
 
 extern "C" {
-    fn main(argc: c_int, argv: *const *const c_char) -> c_int;
+    fn main() -> u16;
+}
+
+unsafe fn _start_inner(argc: usize, argv: *mut (NonNull<u8>, usize)) -> ! {
+    unsafe {
+        let raw_args = match argc == 0 || argv.is_null() {
+            true => None,
+            false => {
+                let args_slice = core::slice::from_raw_parts_mut(argv, argc);
+                let args = NonNull::new_unchecked(args_slice as *mut _);
+                Some(RawArgs { args })
+            }
+        };
+
+        RAW_ARGS.get().write(MaybeUninit::new(raw_args));
+        let results = main();
+
+        exit(results as i32)
+    }
 }
 
 #[no_mangle]
 #[allow(unused)]
-pub extern "C" fn _start() {
+pub extern "C" fn _start(argc: usize, argv: *mut (NonNull<u8>, usize)) {
     unsafe {
         core::arch::asm!(
             "
@@ -17,14 +39,6 @@ pub extern "C" fn _start() {
         ",
             options(nostack)
         );
-        main(0, ptr::null());
-        core::arch::asm!(
-            "
-            xor rax, rax
-            xor rdi, rdi
-            int 0x80
-        ",
-            options(noreturn)
-        );
+        _start_inner(argc, argv);
     };
 }