Switch to using syscall crate directly - without import

Author: jackpot51

src/libstd/sys/redox/condvar.rs

@@ -3,9 +3,8 @@ use intrinsics::{atomic_cxchg, atomic_xadd, atomic_xchg};
 use ptr;
 use time::Duration;
 
-use super::mutex::{mutex_lock, mutex_unlock, Mutex};
-
-use libc::{futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE};
+use sys::mutex::{mutex_lock, mutex_unlock, Mutex};
+use sys::syscall::{futex, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE};
 
 pub struct Condvar {
     lock: UnsafeCell<*mut i32>,

src/libstd/sys/redox/ext/fs.rs

@@ -216,7 +216,6 @@ impl MetadataExt for fs::Metadata {
     }
 }
 
-/* TODO
 /// Add special unix types (block/char device, fifo and socket)
 #[stable(feature = "file_type_ext", since = "1.5.0")]
 pub trait FileTypeExt {
@@ -236,12 +235,11 @@ pub trait FileTypeExt {
 
 #[stable(feature = "file_type_ext", since = "1.5.0")]
 impl FileTypeExt for fs::FileType {
-    fn is_block_device(&self) -> bool { self.as_inner().is(libc::S_IFBLK) }
-    fn is_char_device(&self) -> bool { self.as_inner().is(libc::S_IFCHR) }
-    fn is_fifo(&self) -> bool { self.as_inner().is(libc::S_IFIFO) }
-    fn is_socket(&self) -> bool { self.as_inner().is(libc::S_IFSOCK) }
+    fn is_block_device(&self) -> bool { false /*TODO*/ }
+    fn is_char_device(&self) -> bool { false /*TODO*/ }
+    fn is_fifo(&self) -> bool { false /*TODO*/ }
+    fn is_socket(&self) -> bool { false /*TODO*/ }
 }
-*/
 
 /// Creates a new symbolic link on the filesystem.
 ///

src/libstd/sys/redox/ext/mod.rs

@@ -44,7 +44,7 @@ pub mod prelude {
     #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")]
     pub use super::ffi::{OsStrExt, OsStringExt};
     #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")]
-    pub use super::fs::{PermissionsExt, OpenOptionsExt, MetadataExt};
+    pub use super::fs::{FileTypeExt, PermissionsExt, OpenOptionsExt, MetadataExt};
     #[doc(no_inline)] #[stable(feature = "rust1", since = "1.0.0")]
     pub use super::process::{CommandExt, ExitStatusExt};
 }

src/libstd/sys/redox/ext/process.rs

@@ -86,12 +86,12 @@ pub trait CommandExt {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl CommandExt for process::Command {
     fn uid(&mut self, id: u32) -> &mut process::Command {
-        self.as_inner_mut().uid(id as usize);
+        self.as_inner_mut().uid(id);
         self
     }
 
     fn gid(&mut self, id: u32) -> &mut process::Command {
-        self.as_inner_mut().gid(id as usize);
+        self.as_inner_mut().gid(id);
         self
     }
 

src/libstd/sys/redox/fd.rs

@@ -11,9 +11,8 @@
 #![unstable(reason = "not public", issue = "0", feature = "fd")]
 
 use io::{self, Read};
-use libc;
 use mem;
-use sys::cvt;
+use sys::{cvt, syscall};
 use sys_common::AsInner;
 use sys_common::io::read_to_end_uninitialized;
 
@@ -36,7 +35,7 @@ impl FileDesc {
     }
 
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        cvt(libc::read(self.fd, buf))
+        cvt(syscall::read(self.fd, buf))
     }
 
     pub fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
@@ -45,33 +44,33 @@ impl FileDesc {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        cvt(libc::write(self.fd, buf))
+        cvt(syscall::write(self.fd, buf))
     }
 
     pub fn duplicate(&self) -> io::Result<FileDesc> {
-        let new_fd = cvt(libc::dup(self.fd, &[]))?;
+        let new_fd = cvt(syscall::dup(self.fd, &[]))?;
         Ok(FileDesc::new(new_fd))
     }
 
     pub fn nonblocking(&self) -> io::Result<bool> {
-        let flags = cvt(libc::fcntl(self.fd, libc::F_GETFL, 0))?;
-        Ok(flags & libc::O_NONBLOCK == libc::O_NONBLOCK)
+        let flags = cvt(syscall::fcntl(self.fd, syscall::F_GETFL, 0))?;
+        Ok(flags & syscall::O_NONBLOCK == syscall::O_NONBLOCK)
     }
 
     pub fn set_cloexec(&self) -> io::Result<()> {
-        let mut flags = cvt(libc::fcntl(self.fd, libc::F_GETFL, 0))?;
-        flags |= libc::O_CLOEXEC;
-        cvt(libc::fcntl(self.fd, libc::F_SETFL, flags)).and(Ok(()))
+        let mut flags = cvt(syscall::fcntl(self.fd, syscall::F_GETFL, 0))?;
+        flags |= syscall::O_CLOEXEC;
+        cvt(syscall::fcntl(self.fd, syscall::F_SETFL, flags)).and(Ok(()))
     }
 
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
-        let mut flags = cvt(libc::fcntl(self.fd, libc::F_GETFL, 0))?;
+        let mut flags = cvt(syscall::fcntl(self.fd, syscall::F_GETFL, 0))?;
         if nonblocking {
-            flags |= libc::O_NONBLOCK;
+            flags |= syscall::O_NONBLOCK;
         } else {
-            flags &= !libc::O_NONBLOCK;
+            flags &= !syscall::O_NONBLOCK;
         }
-        cvt(libc::fcntl(self.fd, libc::F_SETFL, flags)).and(Ok(()))
+        cvt(syscall::fcntl(self.fd, syscall::F_SETFL, flags)).and(Ok(()))
     }
 }
 
@@ -96,6 +95,6 @@ impl Drop for FileDesc {
         // the file descriptor was closed or not, and if we retried (for
         // something like EINTR), we might close another valid file descriptor
         // (opened after we closed ours.
-        let _ = libc::close(self.fd);
+        let _ = syscall::close(self.fd);
     }
 }