Emerald: renamed user_std to emerald_std

Author: Amjad50

library/std/Cargo.toml

@@ -59,7 +59,7 @@ r-efi-alloc = { version = "1.0.0", features = ['rustc-dep-of-std']}
 
 [target.'cfg(target_os = "emerald")'.dependencies]
 # This is from `https://github.com/Amjad50/Emerald`, i.e. it must be run from that context
-user_std = { version = "0.2.2", package = "emerald_std", features = ['rustc-dep-of-std'] }
+emerald_std = { version = "0.2.2", features = ['rustc-dep-of-std'] }
 
 [features]
 backtrace = [

library/std/src/os/emerald/io/owned.rs

@@ -176,7 +176,7 @@ impl Drop for OwnedFd {
     #[inline]
     fn drop(&mut self) {
         unsafe {
-            user_std::io::syscall_close(self.fd)
+            emerald_std::io::syscall_close(self.fd)
                 .expect("Invalid FD somehow slipped and should not be closed")
         }
         // unsafe {
@@ -428,7 +428,7 @@ impl<T: AsFd> AsFd for Box<T> {
 impl AsFd for io::Stdin {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDIN) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDIN) }
     }
 }
 
@@ -437,15 +437,15 @@ impl<'a> AsFd for io::StdinLock<'a> {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
         // SAFETY: user code should not close stdin out from under the standard library
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDIN) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDIN) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
 impl AsFd for io::Stdout {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDOUT) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDOUT) }
     }
 }
 
@@ -454,15 +454,15 @@ impl<'a> AsFd for io::StdoutLock<'a> {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
         // SAFETY: user code should not close stdout out from under the standard library
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDOUT) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDOUT) }
     }
 }
 
 #[stable(feature = "io_safety", since = "1.63.0")]
 impl AsFd for io::Stderr {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDERR) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDERR) }
     }
 }
 
@@ -471,6 +471,6 @@ impl<'a> AsFd for io::StderrLock<'a> {
     #[inline]
     fn as_fd(&self) -> BorrowedFd<'_> {
         // SAFETY: user code should not close stderr out from under the standard library
-        unsafe { BorrowedFd::borrow_raw(user_std::io::FD_STDERR) }
+        unsafe { BorrowedFd::borrow_raw(emerald_std::io::FD_STDERR) }
     }
 }

library/std/src/os/emerald/io/raw.rs

@@ -174,47 +174,47 @@ impl IntoRawFd for fs::File {
 impl AsRawFd for io::Stdin {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDIN
+        emerald_std::io::FD_STDIN
     }
 }
 
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawFd for io::Stdout {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDOUT
+        emerald_std::io::FD_STDOUT
     }
 }
 
 #[stable(feature = "asraw_stdio", since = "1.21.0")]
 impl AsRawFd for io::Stderr {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDERR
+        emerald_std::io::FD_STDERR
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawFd for io::StdinLock<'a> {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDIN
+        emerald_std::io::FD_STDIN
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawFd for io::StdoutLock<'a> {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDOUT
+        emerald_std::io::FD_STDOUT
     }
 }
 
 #[stable(feature = "asraw_stdio_locks", since = "1.35.0")]
 impl<'a> AsRawFd for io::StderrLock<'a> {
     #[inline]
     fn as_raw_fd(&self) -> RawFd {
-        user_std::io::FD_STDERR
+        emerald_std::io::FD_STDERR
     }
 }
 

library/std/src/sys/emerald/alloc.rs

@@ -4,21 +4,21 @@ use crate::alloc::{GlobalAlloc, Layout, System};
 unsafe impl GlobalAlloc for System {
     #[inline]
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        unsafe { user_std::alloc::alloc(layout) }
+        unsafe { emerald_std::alloc::alloc(layout) }
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        unsafe { user_std::alloc::alloc_zeroed(layout) }
+        unsafe { emerald_std::alloc::alloc_zeroed(layout) }
     }
 
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        unsafe { user_std::alloc::dealloc(ptr, layout) }
+        unsafe { emerald_std::alloc::dealloc(ptr, layout) }
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        unsafe { user_std::alloc::realloc(ptr, layout, new_size) }
+        unsafe { emerald_std::alloc::realloc(ptr, layout, new_size) }
     }
 }

library/std/src/sys/emerald/fd.rs

@@ -8,7 +8,7 @@ use crate::{
     sys_common::{AsInner, FromInner, IntoInner},
 };
 
-use user_std::io::FileMeta;
+use emerald_std::io::FileMeta;
 
 use super::syscall_to_io_error;
 
@@ -43,7 +43,7 @@ impl FileDesc {
         // })?;
         // Ok(ret as usize)
         let ret = unsafe {
-            user_std::io::syscall_read(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
+            emerald_std::io::syscall_read(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
         };
         Ok(ret as usize)
     }
@@ -84,7 +84,7 @@ impl FileDesc {
             )
         };
         let ret = unsafe {
-            user_std::io::syscall_read(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
+            emerald_std::io::syscall_read(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
         };
 
         // Safety: `ret` bytes were written to the initialized portion of the buffer
@@ -108,7 +108,7 @@ impl FileDesc {
         // })?;
         // Ok(ret as usize)
         let ret = unsafe {
-            user_std::io::syscall_write(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
+            emerald_std::io::syscall_write(self.0.as_raw_fd(), buf).map_err(syscall_to_io_error)?
         };
         Ok(ret as usize)
     }
@@ -201,15 +201,15 @@ impl FileDesc {
 
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
         let blocking_mode = if nonblocking {
-            user_std::io::BlockingMode::None
+            emerald_std::io::BlockingMode::None
         } else {
             todo!("Not sure which mode to put here")
-            // user_std::io::BlockingMode::Line
-            // user_std::io::BlockingMode::Block(1)
+            // emerald_std::io::BlockingMode::Line
+            // emerald_std::io::BlockingMode::Block(1)
         };
 
         unsafe {
-            user_std::io::syscall_set_file_meta(
+            emerald_std::io::syscall_set_file_meta(
                 self.as_raw_fd(),
                 FileMeta::BlockingMode(blocking_mode),
             )

library/std/src/sys/emerald/fs.rs

@@ -1,6 +1,6 @@
 use core::ffi::CStr;
 
-use user_std::io::FileStat;
+use emerald_std::io::FileStat;
 
 use crate::ffi::OsString;
 use crate::fmt;
@@ -32,7 +32,7 @@ pub struct ReadDir {
 }
 
 pub struct DirEntry {
-    system_entry: user_std::io::DirEntry,
+    system_entry: emerald_std::io::DirEntry,
     parent_path: PathBuf,
 }
 
@@ -45,7 +45,7 @@ pub struct FileTimes {}
 pub struct FilePermissions(!);
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-pub struct FileType(user_std::io::FileType);
+pub struct FileType(emerald_std::io::FileType);
 
 #[derive(Debug)]
 pub struct DirBuilder {}
@@ -113,11 +113,11 @@ impl FileTimes {
 
 impl FileType {
     pub fn is_dir(&self) -> bool {
-        self.0 == user_std::io::FileType::Directory
+        self.0 == emerald_std::io::FileType::Directory
     }
 
     pub fn is_file(&self) -> bool {
-        self.0 == user_std::io::FileType::File
+        self.0 == emerald_std::io::FileType::File
     }
 
     pub fn is_symlink(&self) -> bool {
@@ -128,7 +128,7 @@ impl FileType {
 impl ReadDir {
     fn new(path: &Path) -> io::Result<ReadDir> {
         let raw_fd = run_path_with_cstr(path, |path| unsafe {
-            user_std::io::syscall_open_dir(path).map_err(syscall_to_io_error)
+            emerald_std::io::syscall_open_dir(path).map_err(syscall_to_io_error)
         })?;
 
         Ok(ReadDir {
@@ -142,9 +142,9 @@ impl ReadDir {
     fn populate_next_entries(&mut self) -> io::Result<bool> {
         assert!(self.fetched_entries.is_empty());
 
-        let mut entries = [user_std::io::DirEntry::default(); 16];
+        let mut entries = [emerald_std::io::DirEntry::default(); 16];
         let num_entries = unsafe {
-            user_std::io::syscall_read_dir(self.fd.as_raw_fd(), &mut entries)
+            emerald_std::io::syscall_read_dir(self.fd.as_raw_fd(), &mut entries)
                 .map_err(syscall_to_io_error)?
         };
 
@@ -240,7 +240,7 @@ impl File {
         let access_mode = 0;
 
         let fd = unsafe {
-            user_std::io::syscall_open(path, access_mode, flags).map_err(syscall_to_io_error)
+            emerald_std::io::syscall_open(path, access_mode, flags).map_err(syscall_to_io_error)
         }?;
 
         Ok(unsafe { FileDesc::from_raw_fd(fd as usize) })
@@ -428,7 +428,7 @@ pub fn stat(p: &Path) -> io::Result<FileAttr> {
         let mut stat = FileStat::default();
 
         unsafe {
-            user_std::io::syscall_stat(c_path, &mut stat)
+            emerald_std::io::syscall_stat(c_path, &mut stat)
                 .map_err(syscall_to_io_error)
                 .map(|_| FileAttr(stat))
         }

library/std/src/sys/emerald/io.rs

@@ -2,7 +2,7 @@ use crate::mem;
 
 use crate::os::emerald::io::{AsFd, AsRawFd};
 use crate::sys::emerald::syscall_to_io_error;
-use user_std::io::FileMeta;
+use emerald_std::io::FileMeta;
 
 #[derive(Copy, Clone)]
 pub struct IoSlice<'a>(&'a [u8]);
@@ -53,7 +53,7 @@ impl<'a> IoSliceMut<'a> {
 pub fn is_terminal(file: &impl AsFd) -> bool {
     let mut meta = FileMeta::IsTerminal(false);
     unsafe {
-        user_std::io::syscall_get_file_meta(file.as_fd().as_raw_fd(), &mut meta)
+        emerald_std::io::syscall_get_file_meta(file.as_fd().as_raw_fd(), &mut meta)
             .map_err(syscall_to_io_error)
             .expect("syscall_get_file_meta failed");
     }

library/std/src/sys/emerald/mod.rs

@@ -29,7 +29,7 @@ pub mod time;
 mod common;
 pub use common::*;
 
-use user_std::SyscallError;
+use emerald_std::SyscallError;
 
 fn syscall_to_io_error(e: SyscallError) -> crate::io::Error {
     match e {

library/std/src/sys/emerald/os.rs

@@ -1,4 +1,4 @@
-use user_std::SyscallError;
+use emerald_std::SyscallError;
 
 use crate::error::Error as StdError;
 use crate::ffi::{OsStr, OsString};
@@ -40,7 +40,7 @@ pub fn getcwd() -> io::Result<PathBuf> {
             // Safety: the size is equal to the capacity, I'm setting the length so we can access the slice
             //         its safe to use since the data will be overwritten by getcwd
             buf.set_len(buf.capacity());
-            match user_std::io::syscall_get_cwd(&mut buf) {
+            match emerald_std::io::syscall_get_cwd(&mut buf) {
                 Ok(len) => {
                     // Safety: forcing the length back to the safe space
                     buf.set_len(len);
@@ -61,7 +61,7 @@ pub fn getcwd() -> io::Result<PathBuf> {
 
 pub fn chdir(p: &path::Path) -> io::Result<()> {
     run_path_with_cstr(p, |p| unsafe {
-        user_std::io::syscall_chdir(p).map_err(syscall_to_io_error)
+        emerald_std::io::syscall_chdir(p).map_err(syscall_to_io_error)
     })
 }
 
@@ -168,7 +168,7 @@ pub fn home_dir() -> Option<PathBuf> {
 }
 
 pub fn exit(code: i32) -> ! {
-    unsafe { user_std::process::exit(code) }
+    unsafe { emerald_std::process::exit(code) }
 }
 
 pub fn getpid() -> u32 {

library/std/src/sys/emerald/pipe.rs

@@ -1,4 +1,4 @@
-use user_std::io::syscall_create_pipe;
+use emerald_std::io::syscall_create_pipe;
 
 use crate::{
     io::{self, BorrowedCursor, IoSlice, IoSliceMut},