Format

build.rs

@@ -11,9 +11,11 @@ fn main() {
         .include(&format!("{}/include", crate_dir))
         .flag("-fno-stack-protector")
         .flag("-Wno-expansion-to-defined")
-        .files(fs::read_dir("src/c")
-               .expect("src/c directory missing")
-               .map(|res| res.expect("read_dir error").path()))
+        .files(
+            fs::read_dir("src/c")
+                .expect("src/c directory missing")
+                .map(|res| res.expect("read_dir error").path()),
+        )
         .compile("relibc_c");
 
     println!("cargo:rustc-link-lib=static=relibc_c");

rustfmt.toml

@@ -7,7 +7,7 @@ format_strings = false
 empty_item_single_line = true
 fn_single_line = false
 where_single_line = false
-imports_indent = "Visual"
+imports_indent = "Block"
 imports_layout = "Mixed"
 fn_args_density = "Tall"
 brace_style = "SameLineWhere"
@@ -20,3 +20,5 @@ skip_children = false
 hide_parse_errors = false
 report_todo = "Never"
 report_fixme = "Never"
+edition = "2018"
+merge_imports = true

src/c_str.rs

@@ -8,23 +8,23 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use alloc::borrow::{Borrow, Cow, ToOwned};
-use alloc::boxed::Box;
-use alloc::rc::Rc;
-use alloc::string::String;
-use alloc::sync::Arc;
-use alloc::vec::Vec;
-use core::ascii;
-use core::cmp::Ordering;
-use core::fmt::{self, Write};
-use core::mem;
-use core::ops;
-use core::ptr;
-use core::slice;
-use core::str::{self, Utf8Error};
-
-use crate::header::string::strlen;
-use crate::platform::types::*;
+use alloc::{
+    borrow::{Borrow, Cow, ToOwned},
+    boxed::Box,
+    rc::Rc,
+    string::String,
+    sync::Arc,
+    vec::Vec,
+};
+use core::{
+    ascii,
+    cmp::Ordering,
+    fmt::{self, Write},
+    mem, ops, ptr, slice,
+    str::{self, Utf8Error},
+};
+
+use crate::{header::string::strlen, platform::types::*};
 
 pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
     use crate::header::string;

src/c_vec.rs

@@ -1,9 +1,12 @@
-use core::iter::IntoIterator;
-use core::ops::{Deref, DerefMut};
-use core::ptr::{self, NonNull};
-use core::{cmp, mem, slice};
-use crate::platform::types::*;
-use crate::platform;
+use crate::platform::{self, types::*};
+use core::{
+    cmp,
+    iter::IntoIterator,
+    mem,
+    ops::{Deref, DerefMut},
+    ptr::{self, NonNull},
+    slice,
+};
 
 /// Error that occurs when an allocation fails
 #[derive(Debug, Default, Hash, PartialEq, Eq, Clone, Copy)]
@@ -18,14 +21,14 @@ pub struct AllocError;
 pub struct CVec<T> {
     ptr: NonNull<T>,
     len: usize,
-    cap: usize
+    cap: usize,
 }
 impl<T> CVec<T> {
     pub fn new() -> Self {
         Self {
             ptr: NonNull::dangling(),
             len: 0,
-            cap: 0
+            cap: 0,
         }
     }
     fn check_bounds(i: usize) -> Result<usize, AllocError> {
@@ -36,7 +39,8 @@ impl<T> CVec<T> {
         }
     }
     fn check_mul(x: usize, y: usize) -> Result<usize, AllocError> {
-        x.checked_mul(y).ok_or(AllocError)
+        x.checked_mul(y)
+            .ok_or(AllocError)
             .and_then(Self::check_bounds)
     }
     pub fn with_capacity(cap: usize) -> Result<Self, AllocError> {
@@ -45,15 +49,12 @@ impl<T> CVec<T> {
         }
         let size = Self::check_mul(cap, mem::size_of::<T>())?;
         let ptr = NonNull::new(unsafe { platform::alloc(size) as *mut T }).ok_or(AllocError)?;
-        Ok(Self {
-            ptr,
-            len: 0,
-            cap
-        })
+        Ok(Self { ptr, len: 0, cap })
     }
     unsafe fn resize(&mut self, cap: usize) -> Result<(), AllocError> {
         let size = Self::check_mul(cap, mem::size_of::<T>())?;
-        let ptr = NonNull::new(platform::realloc(self.ptr.as_ptr() as *mut c_void, size) as *mut T).ok_or(AllocError)?;
+        let ptr = NonNull::new(platform::realloc(self.ptr.as_ptr() as *mut c_void, size) as *mut T)
+            .ok_or(AllocError)?;
         self.ptr = ptr;
         self.cap = cap;
         Ok(())
@@ -67,7 +68,9 @@ impl<T> CVec<T> {
         }
     }
     pub fn reserve(&mut self, required: usize) -> Result<(), AllocError> {
-        let reserved_len = self.len.checked_add(required)
+        let reserved_len = self
+            .len
+            .checked_add(required)
             .ok_or(AllocError)
             .and_then(Self::check_bounds)?;
         let new_cap = cmp::min(reserved_len.next_power_of_two(), core::isize::MAX as usize);
@@ -87,7 +90,8 @@ impl<T> CVec<T> {
         Ok(())
     }
     pub fn extend_from_slice(&mut self, elems: &[T]) -> Result<(), AllocError>
-        where T: Copy
+    where
+        T: Copy,
     {
         unsafe {
             self.reserve(elems.len())?;
@@ -142,16 +146,12 @@ impl<T> Deref for CVec<T> {
     type Target = [T];
 
     fn deref(&self) -> &Self::Target {
-        unsafe {
-            slice::from_raw_parts(self.ptr.as_ptr(), self.len)
-        }
+        unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len) }
     }
 }
 impl<T> DerefMut for CVec<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe {
-            slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len)
-        }
+        unsafe { slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
     }
 }
 impl<T> Drop for CVec<T> {

src/db.rs

@@ -1,10 +1,11 @@
-use alloc::string::String;
-use alloc::vec::Vec;
-
-use crate::c_str::CStr;
-use crate::fs::File;
-use crate::header::fcntl;
-use crate::io::{self, BufRead, BufReader};
+use alloc::{string::String, vec::Vec};
+
+use crate::{
+    c_str::CStr,
+    fs::File,
+    header::fcntl,
+    io::{self, BufRead, BufReader},
+};
 
 pub enum Separator {
     Character(char),

src/fs.rs

@@ -1,10 +1,13 @@
-use crate::c_str::CStr;
+use crate::{
+    c_str::CStr,
+    header::{
+        fcntl::O_CREAT,
+        unistd::{SEEK_CUR, SEEK_END, SEEK_SET},
+    },
+    io,
+    platform::{types::*, Pal, Sys},
+};
 use core::ops::Deref;
-use crate::header::fcntl::O_CREAT;
-use crate::header::unistd::{SEEK_CUR, SEEK_END, SEEK_SET};
-use crate::io;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
 
 pub struct File {
     pub fd: c_int,

src/header/_aio/mod.rs

@@ -1,5 +1,7 @@
-use crate::header::time::{sigevent, timespec};
-use crate::platform::types::*;
+use crate::{
+    header::time::{sigevent, timespec},
+    platform::types::*,
+};
 
 pub struct aiocb {
     pub aio_fildes: c_int,

src/header/arpa_inet/mod.rs

@@ -1,15 +1,19 @@
 //! arpa/inet implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xns/arpainet.h.html
 
-use core::str::FromStr;
-use core::{ptr, slice, str};
-
-use crate::c_str::CStr;
-use crate::header::errno::*;
-use crate::header::netinet_in::{in_addr, in_addr_t, INADDR_NONE};
-use crate::header::sys_socket::constants::*;
-use crate::header::sys_socket::socklen_t;
-use crate::platform;
-use crate::platform::types::*;
+use core::{
+    ptr, slice,
+    str::{self, FromStr},
+};
+
+use crate::{
+    c_str::CStr,
+    header::{
+        errno::*,
+        netinet_in::{in_addr, in_addr_t, INADDR_NONE},
+        sys_socket::{constants::*, socklen_t},
+    },
+    platform::{self, types::*},
+};
 
 #[no_mangle]
 pub extern "C" fn htonl(hostlong: u32) -> u32 {

src/header/assert/mod.rs

@@ -1,9 +1,11 @@
 //! assert implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/assert.h.html
 
-use crate::c_str::CStr;
+use crate::{
+    c_str::CStr,
+    header::{stdio, stdlib},
+    platform::types::*,
+};
 use core::fmt::Write;
-use crate::header::{stdio, stdlib};
-use crate::platform::types::*;
 
 #[no_mangle]
 pub unsafe extern "C" fn __assert_fail(

src/header/dirent/mod.rs

@@ -3,14 +3,14 @@
 use alloc::boxed::Box;
 use core::{mem, ptr};
 
-use crate::c_str::CStr;
-use crate::c_vec::CVec;
-use crate::fs::File;
-use crate::header::{errno, fcntl, stdlib, string};
-use crate::io::{Seek, SeekFrom};
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
-use crate::platform;
+use crate::{
+    c_str::CStr,
+    c_vec::CVec,
+    fs::File,
+    header::{errno, fcntl, stdlib, string},
+    io::{Seek, SeekFrom},
+    platform::{self, types::*, Pal, Sys},
+};
 
 const DIR_BUF_SIZE: usize = mem::size_of::<dirent>() * 3;
 
@@ -137,7 +137,7 @@ pub unsafe extern "C" fn scandir(
 
     let mut vec = match CVec::with_capacity(4) {
         Ok(vec) => vec,
-        Err(err) => return -1
+        Err(err) => return -1,
     };
 
     let old_errno = platform::errno;

src/header/dl-tls/mod.rs

@@ -1,7 +1,6 @@
 //! dl-tls implementation for Redox
 
-use crate::ld_so::tcb::Tcb;
-use crate::platform::types::*;
+use crate::{ld_so::tcb::Tcb, platform::types::*};
 
 #[repr(C)]
 pub struct dl_tls_index {

src/header/dlfcn/mod.rs

@@ -1,10 +1,11 @@
 //! dlfcn implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html
 
-use core::sync::atomic::{AtomicUsize, Ordering};
-use core::{ptr, str};
+use core::{
+    ptr, str,
+    sync::atomic::{AtomicUsize, Ordering},
+};
 
-use crate::c_str::CStr;
-use crate::platform::types::*;
+use crate::{c_str::CStr, platform::types::*};
 
 pub const RTLD_LAZY: c_int = 0x0001;
 pub const RTLD_NOW: c_int = 0x0002;

src/header/errno/mod.rs

@@ -1,7 +1,6 @@
 //! errno implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/errno.h.html
 
-use crate::platform;
-use crate::platform::types::*;
+use crate::platform::{self, types::*};
 
 //TODO: Consider removing, provided for compatibility with newlib
 #[no_mangle]

src/header/fcntl/mod.rs

@@ -1,8 +1,9 @@
 //! fcntl implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/fcntl.h.html
 
-use crate::c_str::CStr;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::CStr,
+    platform::{types::*, Pal, Sys},
+};
 
 pub use self::sys::*;
 

src/header/float/mod.rs

@@ -1,8 +1,10 @@
 //! float.h implementation for Redox, following
 //! http://pubs.opengroup.org/onlinepubs/7908799/xsh/float.h.html
 
-use crate::header::_fenv::{fegetround, FE_TONEAREST};
-use crate::platform::types::*;
+use crate::{
+    header::_fenv::{fegetround, FE_TONEAREST},
+    platform::types::*,
+};
 
 pub const FLT_RADIX: c_int = 2;
 

src/header/fnmatch/mod.rs

@@ -1,12 +1,13 @@
 //! fnmatch implementation
 
-use alloc::borrow::Cow;
-use alloc::vec::Vec;
+use alloc::{borrow::Cow, vec::Vec};
 use core::slice;
 
 use crate::platform::types::*;
-use posix_regex::compile::{Collation, Range, Token};
-use posix_regex::PosixRegex;
+use posix_regex::{
+    compile::{Collation, Range, Token},
+    PosixRegex,
+};
 
 const ONCE: Range = Range(1, Some(1));
 

src/header/getopt/mod.rs

@@ -1,9 +1,13 @@
 //! getopt implementation for relibc
 
+use crate::{
+    header::{
+        stdio, string,
+        unistd::{optarg, opterr, optind, optopt},
+    },
+    platform::types::*,
+};
 use core::ptr;
-use crate::header::unistd::{optarg, opterr, optind, optopt};
-use crate::header::{stdio, string};
-use crate::platform::types::*;
 
 static mut CURRENT_OPT: *mut c_char = ptr::null_mut();
 

src/header/inttypes/mod.rs

@@ -1,8 +1,7 @@
-use crate::header::ctype;
-use crate::header::errno::*;
-use crate::header::stdlib::*;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::{ctype, errno::*, stdlib::*},
+    platform::{self, types::*},
+};
 
 #[no_mangle]
 pub extern "C" fn imaxabs(i: intmax_t) -> intmax_t {

src/header/netdb/dns/answer.rs

@@ -8,8 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use alloc::string::String;
-use alloc::vec::Vec;
+use alloc::{string::String, vec::Vec};
 
 #[derive(Clone, Debug)]
 pub struct DnsAnswer {

src/header/netdb/dns/mod.rs

@@ -8,13 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub use self::answer::DnsAnswer;
-pub use self::query::DnsQuery;
+pub use self::{answer::DnsAnswer, query::DnsQuery};
 
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::slice;
-use core::u16;
+use alloc::{string::String, vec::Vec};
+use core::{slice, u16};
 
 mod answer;
 mod query;

src/header/netdb/host.rs

@@ -1,17 +1,18 @@
-use alloc::boxed::Box;
-use alloc::str::SplitWhitespace;
-use alloc::vec::Vec;
+use alloc::{boxed::Box, str::SplitWhitespace, vec::Vec};
 use core::{mem, ptr};
 
-use crate::c_str::CString;
-use crate::header::arpa_inet::inet_aton;
-use crate::header::fcntl::O_RDONLY;
-use crate::header::netinet_in::in_addr;
-use crate::header::sys_socket::constants::AF_INET;
-use crate::header::unistd::SEEK_SET;
-use crate::platform::rlb::{Line, RawLineBuffer};
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::CString,
+    header::{
+        arpa_inet::inet_aton, fcntl::O_RDONLY, netinet_in::in_addr, sys_socket::constants::AF_INET,
+        unistd::SEEK_SET,
+    },
+    platform::{
+        rlb::{Line, RawLineBuffer},
+        types::*,
+        Pal, Sys,
+    },
+};
 
 use super::{bytes_to_box_str, hostent};
 

src/header/netdb/linux.rs

@@ -1,8 +1,10 @@
+use crate::{
+    c_str::CString,
+    fs::File,
+    header::fcntl,
+    io::{BufRead, BufReader},
+};
 use alloc::string::String;
-use crate::c_str::CString;
-use crate::fs::File;
-use crate::header::fcntl;
-use crate::io::{BufRead, BufReader};
 
 pub fn get_dns_server() -> String {
     let file = match File::open(&CString::new("/etc/resolv.conf").unwrap(), fcntl::O_RDONLY) {

src/header/netdb/lookup.rs

@@ -1,22 +1,28 @@
-use alloc::boxed::Box;
-use alloc::string::{String, ToString};
-use alloc::vec::{IntoIter, Vec};
+use alloc::{
+    boxed::Box,
+    string::{String, ToString},
+    vec::{IntoIter, Vec},
+};
 use core::mem;
 
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
-
-use crate::header::arpa_inet::htons;
-use crate::header::errno::*;
-use crate::header::netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP};
-use crate::header::sys_socket;
-use crate::header::sys_socket::constants::{AF_INET, SOCK_DGRAM};
-use crate::header::sys_socket::{sockaddr, socklen_t};
-use crate::header::time;
-use crate::header::time::timespec;
-
-use super::dns::{Dns, DnsQuery};
-use super::sys::get_dns_server;
+use crate::platform::{types::*, Pal, Sys};
+
+use crate::header::{
+    arpa_inet::htons,
+    errno::*,
+    netinet_in::{in_addr, sockaddr_in, IPPROTO_UDP},
+    sys_socket::{
+        self,
+        constants::{AF_INET, SOCK_DGRAM},
+        sockaddr, socklen_t,
+    },
+    time::{self, timespec},
+};
+
+use super::{
+    dns::{Dns, DnsQuery},
+    sys::get_dns_server,
+};
 
 pub struct LookupHost(IntoIter<in_addr>);
 

src/header/netdb/mod.rs

@@ -2,28 +2,32 @@
 
 mod dns;
 
-use core::str::FromStr;
-use core::{mem, ptr, slice, str};
-
-use alloc::borrow::ToOwned;
-use alloc::boxed::Box;
-use alloc::str::SplitWhitespace;
-use alloc::vec::Vec;
-
-use crate::c_str::{CStr, CString};
-use crate::header::arpa_inet::htons;
-use crate::header::errno::*;
-use crate::header::fcntl::O_RDONLY;
-use crate::header::netinet_in::{in_addr, sockaddr_in, sockaddr_in6};
-use crate::header::stdlib::atoi;
-use crate::header::strings::strcasecmp;
-use crate::header::sys_socket::constants::AF_INET;
-use crate::header::sys_socket::{sa_family_t, sockaddr, socklen_t};
-use crate::header::unistd::SEEK_SET;
-use crate::platform;
-use crate::platform::rlb::{Line, RawLineBuffer};
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use core::{
+    mem, ptr, slice,
+    str::{self, FromStr},
+};
+
+use alloc::{borrow::ToOwned, boxed::Box, str::SplitWhitespace, vec::Vec};
+
+use crate::{
+    c_str::{CStr, CString},
+    header::{
+        arpa_inet::htons,
+        errno::*,
+        fcntl::O_RDONLY,
+        netinet_in::{in_addr, sockaddr_in, sockaddr_in6},
+        stdlib::atoi,
+        strings::strcasecmp,
+        sys_socket::{constants::AF_INET, sa_family_t, sockaddr, socklen_t},
+        unistd::SEEK_SET,
+    },
+    platform::{
+        self,
+        rlb::{Line, RawLineBuffer},
+        types::*,
+        Pal, Sys,
+    },
+};
 
 #[cfg(target_os = "linux")]
 #[path = "linux.rs"]

src/header/netdb/redox.rs

@@ -1,8 +1,5 @@
+use crate::{c_str::CString, fs::File, header::fcntl, io::Read};
 use alloc::string::String;
-use crate::c_str::CString;
-use crate::fs::File;
-use crate::header::fcntl;
-use crate::io::Read;
 
 pub fn get_dns_server() -> String {
     let mut string = String::new();

src/header/netinet_in/mod.rs

@@ -1,7 +1,6 @@
 #![allow(non_camel_case_types)]
 
-use crate::header::sys_socket::sa_family_t;
-use crate::platform::types::*;
+use crate::{header::sys_socket::sa_family_t, platform::types::*};
 
 pub type in_addr_t = u32;
 pub type in_port_t = u16;

src/header/poll/mod.rs

@@ -2,11 +2,14 @@
 
 use core::{mem, slice};
 
-use crate::fs::File;
-use crate::header::sys_epoll::{epoll_create1, epoll_ctl, epoll_data, epoll_event, epoll_wait, EPOLLERR,
-                        EPOLLHUP, EPOLLIN, EPOLLNVAL, EPOLLOUT, EPOLLPRI, EPOLL_CLOEXEC,
-                        EPOLL_CTL_ADD};
-use crate::platform::types::*;
+use crate::{
+    fs::File,
+    header::sys_epoll::{
+        epoll_create1, epoll_ctl, epoll_data, epoll_event, epoll_wait, EPOLLERR, EPOLLHUP, EPOLLIN,
+        EPOLLNVAL, EPOLLOUT, EPOLLPRI, EPOLL_CLOEXEC, EPOLL_CTL_ADD,
+    },
+    platform::types::*,
+};
 
 pub const POLLIN: c_short = 0x001;
 pub const POLLPRI: c_short = 0x002;

src/header/pwd/mod.rs

@@ -2,11 +2,12 @@
 
 use core::ptr;
 
-use crate::fs::File;
-use crate::header::{errno, fcntl};
-use crate::io::{BufRead, BufReader};
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    fs::File,
+    header::{errno, fcntl},
+    io::{BufRead, BufReader},
+    platform::{self, types::*},
+};
 
 #[cfg(target_os = "linux")]
 mod linux;

src/header/regex/mod.rs

@@ -1,12 +1,12 @@
 //! regex.h implementation, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/regex.h.html
 
-use alloc::borrow::Cow;
-use alloc::vec::Vec;
+use crate::{header::string::strlen, platform::types::*};
+use alloc::{borrow::Cow, vec::Vec};
 use core::{mem, ptr, slice};
-use crate::header::string::strlen;
-use crate::platform::types::*;
-use posix_regex::compile::{Error as CompileError, Range, Token};
-use posix_regex::{PosixRegex, PosixRegexBuilder};
+use posix_regex::{
+    compile::{Error as CompileError, Range, Token},
+    PosixRegex, PosixRegexBuilder,
+};
 
 pub type regoff_t = size_t;
 

src/header/sgtty/mod.rs

@@ -1,7 +1,6 @@
 //! sgtty implementation that won't work on redox because no ioctl
 
-use crate::header::sys_ioctl::*;
-use crate::platform::types::*;
+use crate::{header::sys_ioctl::*, platform::types::*};
 
 #[no_mangle]
 pub extern "C" fn gtty(fd: c_int, out: *mut sgttyb) -> c_int {

src/header/signal/mod.rs

@@ -4,10 +4,10 @@ use core::{mem, ptr};
 
 use cbitset::BitSet;
 
-use crate::header::errno;
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{PalSignal, Sys};
+use crate::{
+    header::errno,
+    platform::{self, types::*, PalSignal, Sys},
+};
 
 pub use self::sys::*;
 

src/header/stdio/default.rs

@@ -1,11 +1,7 @@
 use super::{constants, Buffer, BUFSIZ, FILE};
-use core::cell::UnsafeCell;
-use core::ptr;
+use core::{cell::UnsafeCell, ptr};
 
-use crate::fs::File;
-use crate::io::LineWriter;
-use crate::platform::types::*;
-use crate::sync::Mutex;
+use crate::{fs::File, io::LineWriter, platform::types::*, sync::Mutex};
 
 pub struct GlobalFile(UnsafeCell<FILE>);
 impl GlobalFile {

src/header/stdio/ext.rs

@@ -1,5 +1,7 @@
-use crate::header::stdio::{FILE, F_NORD, F_NOWR};
-use crate::platform::types::*;
+use crate::{
+    header::stdio::{FILE, F_NORD, F_NOWR},
+    platform::types::*,
+};
 
 #[no_mangle]
 pub extern "C" fn __fpending(stream: *mut FILE) -> size_t {

src/header/stdio/getdelim.rs

@@ -1,10 +1,11 @@
 use alloc::vec::Vec;
 use core::ptr;
 
-use crate::header::stdio::FILE;
-use crate::header::stdlib;
-use crate::io::BufRead;
-use crate::platform::types::*;
+use crate::{
+    header::{stdio::FILE, stdlib},
+    io::BufRead,
+    platform::types::*,
+};
 
 #[no_mangle]
 pub unsafe extern "C" fn __getline(

src/header/stdio/helpers.rs

@@ -1,16 +1,14 @@
 use alloc::boxed::Box;
 
-use crate::fs::File;
-use crate::header::errno;
-use crate::header::fcntl::*;
-use crate::header::string::strchr;
-use crate::io::LineWriter;
-use crate::platform;
-use crate::platform::types::*;
-use crate::sync::Mutex;
+use crate::{
+    fs::File,
+    header::{errno, fcntl::*, string::strchr},
+    io::LineWriter,
+    platform::{self, types::*},
+    sync::Mutex,
+};
 
-use super::constants::*;
-use super::{Buffer, FILE};
+use super::{constants::*, Buffer, FILE};
 
 /// Parse mode flags as a string and output a mode flags integer
 pub unsafe fn parse_mode_flags(mode_str: *const c_char) -> i32 {

src/header/stdio/mod.rs

@@ -1,24 +1,31 @@
 //! stdio implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/stdio.h.html
 
-use alloc::borrow::{Borrow, BorrowMut};
-use alloc::boxed::Box;
-use alloc::vec::Vec;
-use core::ffi::VaList as va_list;
-use core::fmt::Write as WriteFmt;
-use core::ops::{Deref, DerefMut};
-use core::{fmt, mem, ptr, slice, str};
-
-use crate::c_str::CStr;
-use crate::fs::File;
-use crate::header::errno::{self, STR_ERROR};
-use crate::header::string::{self, strlen};
-use crate::header::{fcntl, stdlib, unistd};
-use crate::io::{self, BufRead, LineWriter, Read, Write};
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{errno, WriteByte};
-use crate::platform::{Pal, Sys};
-use crate::sync::Mutex;
+use alloc::{
+    borrow::{Borrow, BorrowMut},
+    boxed::Box,
+    vec::Vec,
+};
+use core::{
+    ffi::VaList as va_list,
+    fmt::{self, Write as WriteFmt},
+    mem,
+    ops::{Deref, DerefMut},
+    ptr, slice, str,
+};
+
+use crate::{
+    c_str::CStr,
+    fs::File,
+    header::{
+        errno::{self, STR_ERROR},
+        fcntl, stdlib,
+        string::{self, strlen},
+        unistd,
+    },
+    io::{self, BufRead, LineWriter, Read, Write},
+    platform::{self, errno, types::*, Pal, Sys, WriteByte},
+    sync::Mutex,
+};
 
 pub use self::constants::*;
 mod constants;

src/header/stdio/printf.rs

@@ -1,15 +1,15 @@
-use alloc::collections::BTreeMap;
-use alloc::string::String;
-use alloc::string::ToString;
-use alloc::vec::Vec;
-use core::ffi::VaList;
-use core::ops::Range;
-use core::{char, cmp, f64, fmt, slice};
 use crate::io::{self, Write};
-
-use crate::header::errno::EILSEQ;
-use crate::platform::types::*;
-use crate::platform;
+use alloc::{
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec::Vec,
+};
+use core::{char, cmp, f64, ffi::VaList, fmt, ops::Range, slice};
+
+use crate::{
+    header::errno::EILSEQ,
+    platform::{self, types::*},
+};
 
 //  ____        _ _                 _       _
 // | __ )  ___ (_) | ___ _ __ _ __ | | __ _| |_ ___ _
@@ -103,8 +103,9 @@ impl VaArg {
         match (fmtkind, intkind) {
             (FmtKind::Percent, _) => panic!("Can't call arg_from on %"),
 
-            (FmtKind::Char, IntKind::Long)
-            | (FmtKind::Char, IntKind::LongLong) => VaArg::wint_t(ap.arg::<wint_t>()),
+            (FmtKind::Char, IntKind::Long) | (FmtKind::Char, IntKind::LongLong) => {
+                VaArg::wint_t(ap.arg::<wint_t>())
+            }
 
             (FmtKind::Char, _)
             | (FmtKind::Unsigned, IntKind::Byte)
@@ -178,8 +179,9 @@ impl VaArg {
         match (fmtkind, intkind) {
             (FmtKind::Percent, _) => panic!("Can't call transmute on %"),
 
-            (FmtKind::Char, IntKind::Long)
-            | (FmtKind::Char, IntKind::LongLong) => VaArg::wint_t(untyped.wint_t),
+            (FmtKind::Char, IntKind::Long) | (FmtKind::Char, IntKind::LongLong) => {
+                VaArg::wint_t(untyped.wint_t)
+            }
 
             (FmtKind::Char, _)
             | (FmtKind::Unsigned, IntKind::Byte)
@@ -843,30 +845,28 @@ unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, mut ap: VaList) ->
                     }
                 }
             }
-            FmtKind::Char => {
-                match varargs.get(index, &mut ap, Some((arg.fmtkind, arg.intkind))) {
-                    VaArg::c_char(c) => {
-                        pad(w, !left, b' ', 1..pad_space)?;
-                        w.write_all(&[c as u8])?;
-                        pad(w, left, b' ', 1..pad_space)?;
-                    },
-                    VaArg::wint_t(c) => {
-                        let c = match char::from_u32(c as _) {
-                            Some(c) => c,
-                            None => {
-                                platform::errno = EILSEQ;
-                                return Err(io::last_os_error());
-                            }
-                        };
-                        let mut buf = [0; 4];
-
-                        pad(w, !left, b' ', 1..pad_space)?;
-                        w.write_all(c.encode_utf8(&mut buf).as_bytes())?;
-                        pad(w, left, b' ', 1..pad_space)?;
-                    },
-                    _ => unreachable!("this should not be possible"),
+            FmtKind::Char => match varargs.get(index, &mut ap, Some((arg.fmtkind, arg.intkind))) {
+                VaArg::c_char(c) => {
+                    pad(w, !left, b' ', 1..pad_space)?;
+                    w.write_all(&[c as u8])?;
+                    pad(w, left, b' ', 1..pad_space)?;
                 }
-            }
+                VaArg::wint_t(c) => {
+                    let c = match char::from_u32(c as _) {
+                        Some(c) => c,
+                        None => {
+                            platform::errno = EILSEQ;
+                            return Err(io::last_os_error());
+                        }
+                    };
+                    let mut buf = [0; 4];
+
+                    pad(w, !left, b' ', 1..pad_space)?;
+                    w.write_all(c.encode_utf8(&mut buf).as_bytes())?;
+                    pad(w, left, b' ', 1..pad_space)?;
+                }
+                _ => unreachable!("this should not be possible"),
+            },
             FmtKind::Pointer => {
                 let ptr = match varargs.get(index, &mut ap, Some((arg.fmtkind, arg.intkind))) {
                     VaArg::pointer(p) => p,

src/header/stdio/scanf.rs

@@ -1,8 +1,6 @@
-use alloc::string::String;
-use alloc::vec::Vec;
+use crate::{io::Read, platform::types::*};
+use alloc::{string::String, vec::Vec};
 use core::ffi::VaList as va_list;
-use crate::io::Read;
-use crate::platform::types::*;
 
 #[derive(PartialEq, Eq)]
 enum IntKind {
@@ -404,7 +402,8 @@ unsafe fn inner_scanf<R: Read>(
                     let mut ptr: Option<*mut c_char> = if ignore { None } else { Some(ap.arg()) };
 
                     // While we haven't used up all the width, and it matches
-                    while width.map(|w| w > 0).unwrap_or(true) && !invert == matches.contains(&byte) {
+                    while width.map(|w| w > 0).unwrap_or(true) && !invert == matches.contains(&byte)
+                    {
                         if let Some(ref mut ptr) = ptr {
                             **ptr = byte as c_char;
                             *ptr = ptr.offset(1);

src/header/stdlib/mod.rs

@@ -1,26 +1,28 @@
 //! stdlib implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/stdlib.h.html
 
-use core::convert::TryFrom;
-use core::{intrinsics, iter, mem, ptr, slice};
-use rand::distributions::{Alphanumeric, Distribution, Uniform};
-use rand::prng::XorShiftRng;
-use rand::rngs::JitterRng;
-use rand::{Rng, SeedableRng};
-
-use crate::c_str::CStr;
-use crate::fs::File;
-use crate::header::errno::*;
-use crate::header::fcntl::*;
-use crate::header::limits;
-use crate::header::string::*;
-use crate::header::time::constants::CLOCK_MONOTONIC;
-use crate::header::time::timespec;
-use crate::header::unistd::{sysconf, _SC_PAGESIZE};
-use crate::header::wchar::*;
-use crate::header::{ctype, errno, unistd};
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use core::{convert::TryFrom, intrinsics, iter, mem, ptr, slice};
+use rand::{
+    distributions::{Alphanumeric, Distribution, Uniform},
+    prng::XorShiftRng,
+    rngs::JitterRng,
+    Rng, SeedableRng,
+};
+
+use crate::{
+    c_str::CStr,
+    fs::File,
+    header::{
+        ctype,
+        errno::{self, *},
+        fcntl::*,
+        limits,
+        string::*,
+        time::{constants::CLOCK_MONOTONIC, timespec},
+        unistd::{self, sysconf, _SC_PAGESIZE},
+        wchar::*,
+    },
+    platform::{self, types::*, Pal, Sys},
+};
 
 mod lcg48;
 mod sort;

src/header/string/mod.rs

@@ -4,10 +4,10 @@ use core::{mem, ptr, slice, usize};
 
 use cbitset::BitSet256;
 
-use crate::header::errno::*;
-use crate::header::signal;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::{errno::*, signal},
+    platform::{self, types::*},
+};
 
 #[no_mangle]
 pub unsafe extern "C" fn memccpy(

src/header/strings/mod.rs

@@ -2,8 +2,10 @@
 
 use core::ptr;
 
-use crate::header::{ctype, string};
-use crate::platform::types::*;
+use crate::{
+    header::{ctype, string},
+    platform::types::*,
+};
 
 #[no_mangle]
 pub unsafe extern "C" fn bcmp(first: *const c_void, second: *const c_void, n: size_t) -> c_int {

src/header/sys_epoll/mod.rs

@@ -2,9 +2,10 @@
 
 use core::ptr;
 
-use crate::header::signal::sigset_t;
-use crate::platform::types::*;
-use crate::platform::{PalEpoll, Sys};
+use crate::{
+    header::signal::sigset_t,
+    platform::{types::*, PalEpoll, Sys},
+};
 
 pub use self::sys::*;
 

src/header/sys_file/mod.rs

@@ -1,7 +1,6 @@
 //! sys/file.h implementation
 
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::platform::{types::*, Pal, Sys};
 
 pub const LOCK_SH: usize = 1;
 pub const LOCK_EX: usize = 2;

src/header/sys_ioctl/linux.rs

@@ -1,5 +1,4 @@
-use crate::platform::types::*;
-use crate::platform::Sys;
+use crate::platform::{types::*, Sys};
 
 #[no_mangle]
 pub unsafe extern "C" fn ioctl(fd: c_int, request: c_ulong, out: *mut c_void) -> c_int {

src/header/sys_ioctl/redox.rs

@@ -1,11 +1,10 @@
 use core::{mem, slice};
 use syscall;
 
-use crate::header::errno;
-use crate::header::termios;
-use crate::platform;
-use crate::platform::e;
-use crate::platform::types::*;
+use crate::{
+    header::{errno, termios},
+    platform::{self, e, types::*},
+};
 
 use super::winsize;
 

src/header/sys_mman/mod.rs

@@ -1,7 +1,8 @@
-use crate::c_str::{CStr, CString};
-use crate::header::{fcntl, unistd};
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::{CStr, CString},
+    header::{fcntl, unistd},
+    platform::{types::*, Pal, Sys},
+};
 
 pub use self::sys::*;
 

src/header/sys_ptrace/mod.rs

@@ -1,8 +1,7 @@
 //! ptrace compatibility layer for Redox OS
 
+use crate::platform::{types::*, PalPtrace, Sys};
 use core::ffi::VaList;
-use crate::platform::types::*;
-use crate::platform::{PalPtrace, Sys};
 
 pub const PTRACE_TRACEME: c_int = 0;
 pub const PTRACE_PEEKTEXT: c_int = 1;

src/header/sys_select/mod.rs

@@ -4,13 +4,18 @@ use core::mem;
 
 use cbitset::BitSet;
 
-use crate::fs::File;
-use crate::header::errno;
-use crate::header::sys_epoll::{epoll_create1, epoll_ctl, epoll_data, epoll_event, epoll_wait, EPOLLERR,
-                        EPOLLIN, EPOLLOUT, EPOLL_CLOEXEC, EPOLL_CTL_ADD};
-use crate::header::sys_time::timeval;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    fs::File,
+    header::{
+        errno,
+        sys_epoll::{
+            epoll_create1, epoll_ctl, epoll_data, epoll_event, epoll_wait, EPOLLERR, EPOLLIN,
+            EPOLLOUT, EPOLL_CLOEXEC, EPOLL_CTL_ADD,
+        },
+        sys_time::timeval,
+    },
+    platform::{self, types::*},
+};
 
 // fd_set is also defined in C because cbindgen is incompatible with mem::size_of booo
 

src/header/sys_socket/mod.rs

@@ -2,8 +2,7 @@
 
 use core::ptr;
 
-use crate::platform::types::*;
-use crate::platform::{PalSocket, Sys};
+use crate::platform::{types::*, PalSocket, Sys};
 
 pub mod constants;
 

src/header/sys_stat/mod.rs

@@ -1,10 +1,13 @@
 //! stat implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/sysstat.h.html
 
-use crate::c_str::CStr;
-use crate::header::fcntl::{O_NOFOLLOW, O_PATH};
-use crate::header::time::timespec;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::CStr,
+    header::{
+        fcntl::{O_NOFOLLOW, O_PATH},
+        time::timespec,
+    },
+    platform::{types::*, Pal, Sys},
+};
 
 pub const S_IFMT: c_int = 0o0_170_000;
 

src/header/sys_statvfs/mod.rs

@@ -1,9 +1,10 @@
 //! statvfs implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/sysstatvfs.h.html
 
-use crate::c_str::CStr;
-use crate::header::fcntl::O_PATH;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::CStr,
+    header::fcntl::O_PATH,
+    platform::{types::*, Pal, Sys},
+};
 
 //pub const ST_RDONLY
 //pub const ST_NOSUID

src/header/sys_time/mod.rs

@@ -1,9 +1,10 @@
 //! sys/time implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/systime.h.html
 
-use crate::c_str::CStr;
-use crate::header::time::timespec;
-use crate::platform::types::*;
-use crate::platform::{Pal, PalSignal, Sys};
+use crate::{
+    c_str::CStr,
+    header::time::timespec,
+    platform::{types::*, Pal, PalSignal, Sys},
+};
 
 pub const ITIMER_REAL: c_int = 0;
 pub const ITIMER_VIRTUAL: c_int = 1;

src/header/sys_timeb/mod.rs

@@ -1,7 +1,9 @@
 //! sys/time implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/systime.h.html
 
-use crate::header::sys_time::{gettimeofday, timeval, timezone};
-use crate::platform::types::*;
+use crate::{
+    header::sys_time::{gettimeofday, timeval, timezone},
+    platform::types::*,
+};
 
 #[repr(C)]
 #[derive(Default)]

src/header/sys_uio/mod.rs

@@ -3,9 +3,10 @@
 use alloc::vec::Vec;
 use core::slice;
 
-use crate::header::{errno, unistd};
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::{errno, unistd},
+    platform::{self, types::*},
+};
 
 pub const IOV_MAX: c_int = 1024;
 

src/header/sys_un/mod.rs

@@ -1,5 +1,4 @@
-use crate::header::sys_socket::sa_family_t;
-use crate::platform::types::*;
+use crate::{header::sys_socket::sa_family_t, platform::types::*};
 
 #[repr(C)]
 pub struct sockaddr_un {

src/header/sys_utsname/mod.rs

@@ -1,7 +1,6 @@
 //! sys/utsname implementation, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/sysutsname.h.html
 
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::platform::{types::*, Pal, Sys};
 
 pub const UTSLENGTH: usize = 65;
 

src/header/sys_wait/mod.rs

@@ -2,8 +2,7 @@
 //! http://pubs.opengroup.org/onlinepubs/7908799/xsh/syswait.h.html
 
 //use header::sys_resource::rusage;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::platform::{types::*, Pal, Sys};
 
 pub const WNOHANG: c_int = 1;
 pub const WUNTRACED: c_int = 2;

src/header/termios/mod.rs

@@ -1,9 +1,9 @@
 //! termios implementation, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/termios.h.html
 
-use crate::header::errno;
-use crate::header::sys_ioctl;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::{errno, sys_ioctl},
+    platform::{self, types::*},
+};
 
 pub type cc_t = u8;
 pub type speed_t = u32;

src/header/time/mod.rs

@@ -1,9 +1,9 @@
 //! time implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/time.h.html
 
-use crate::header::errno::EIO;
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    header::errno::EIO,
+    platform::{self, types::*, Pal, Sys},
+};
 
 use self::constants::*;
 

src/header/time/strftime.rs

@@ -1,7 +1,6 @@
 use alloc::string::String;
 
-use crate::platform::types::*;
-use crate::platform::{self, WriteByte};
+use crate::platform::{self, types::*, WriteByte};
 
 use super::tm;
 

src/header/unistd/brk.rs

@@ -1,9 +1,9 @@
 use core::ptr;
 
-use crate::header::errno::ENOMEM;
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    header::errno::ENOMEM,
+    platform::{self, types::*, Pal, Sys},
+};
 
 static mut BRK: *mut c_void = ptr::null_mut();
 

src/header/unistd/getopt.rs

@@ -2,8 +2,7 @@
 
 use core::ptr;
 
-use crate::header::getopt;
-use crate::platform::types::*;
+use crate::{header::getopt, platform::types::*};
 
 #[allow(non_upper_case_globals)]
 #[no_mangle]

src/header/unistd/mod.rs

@@ -1,25 +1,15 @@
 //! unistd implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/unistd.h.html
 
-use core::convert::TryFrom;
-use core::{mem, ptr, slice};
+use core::{convert::TryFrom, mem, ptr, slice};
 
+use crate::{
+    c_str::CStr,
+    header::{errno, limits, stdlib::getenv, sys_ioctl, sys_time, termios, time::timespec},
+    platform::{self, types::*, Pal, Sys},
+};
 use alloc::collections::LinkedList;
-use crate::c_str::CStr;
-use crate::header::errno;
-use crate::header::limits;
-use crate::header::stdlib::getenv;
-use crate::header::sys_ioctl;
-use crate::header::sys_time;
-use crate::header::termios;
-use crate::header::time::timespec;
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
-
-pub use self::brk::*;
-pub use self::getopt::*;
-pub use self::pathconf::*;
-pub use self::sysconf::*;
+
+pub use self::{brk::*, getopt::*, pathconf::*, sysconf::*};
 
 mod brk;
 mod getopt;

src/header/unistd/pathconf.rs

@@ -1,6 +1,7 @@
-use crate::header::errno;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::errno,
+    platform::{self, types::*},
+};
 
 pub const _PC_LINK_MAX: c_int = 0;
 pub const _PC_MAX_CANON: c_int = 1;

src/header/unistd/sysconf.rs

@@ -1,6 +1,7 @@
-use crate::header::errno;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::errno,
+    platform::{self, types::*},
+};
 
 // POSIX.1 {
 pub const _SC_ARG_MAX: c_int = 0;

src/header/utime/mod.rs

@@ -1,9 +1,10 @@
 //! utime implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/utime.h.html
 
-use crate::c_str::CStr;
-use crate::header::time::timespec;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    c_str::CStr,
+    header::time::timespec,
+    platform::{types::*, Pal, Sys},
+};
 
 #[repr(C)]
 #[derive(Clone)]

src/header/wchar/mod.rs

@@ -1,16 +1,11 @@
 //! wchar implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/wchar.h.html
 
-use core::ffi::VaList as va_list;
-use core::{char, mem, ptr, usize};
-
-use crate::header::ctype::isspace;
-use crate::header::errno::ERANGE;
-use crate::header::stdio::*;
-use crate::header::stdlib::MB_CUR_MAX;
-use crate::header::string;
-use crate::header::time::*;
-use crate::platform;
-use crate::platform::types::*;
+use core::{char, ffi::VaList as va_list, mem, ptr, usize};
+
+use crate::{
+    header::{ctype::isspace, errno::ERANGE, stdio::*, stdlib::MB_CUR_MAX, string, time::*},
+    platform::{self, types::*},
+};
 
 mod utf8;
 
@@ -477,7 +472,7 @@ macro_rules! skipws {
         while isspace(*$ptr) != 0 {
             $ptr = $ptr.add(1);
         }
-    }
+    };
 }
 
 #[no_mangle]
@@ -565,13 +560,15 @@ macro_rules! strtou_impl {
         }
 
         let mut result: $type = 0;
-        while let Some(digit) = char::from_u32(*$ptr as u32).and_then(|c| c.to_digit($base as u32)) {
-            let new = result.checked_mul($base as $type)
-                .and_then(|result| if $negative {
+        while let Some(digit) = char::from_u32(*$ptr as u32).and_then(|c| c.to_digit($base as u32))
+        {
+            let new = result.checked_mul($base as $type).and_then(|result| {
+                if $negative {
                     result.checked_sub(digit as $type)
                 } else {
                     result.checked_add(digit as $type)
-                });
+                }
+            });
             result = match new {
                 Some(new) => new,
                 None => {
@@ -583,7 +580,7 @@ macro_rules! strtou_impl {
             $ptr = $ptr.add(1);
         }
         result
-    }}
+    }};
 }
 macro_rules! strto_impl {
     ($type:ident, $ptr:expr, $base:expr) => {{
@@ -592,11 +589,15 @@ macro_rules! strto_impl {
             $ptr = $ptr.add(1);
         }
         strtou_impl!($type, $ptr, $base, negative)
-    }}
+    }};
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcstol(mut ptr: *const wchar_t, end: *mut *mut wchar_t, base: c_int) -> c_long {
+pub unsafe extern "C" fn wcstol(
+    mut ptr: *const wchar_t,
+    end: *mut *mut wchar_t,
+    base: c_int,
+) -> c_long {
     skipws!(ptr);
     let result = strto_impl!(c_long, ptr, base);
     if !end.is_null() {
@@ -606,7 +607,11 @@ pub unsafe extern "C" fn wcstol(mut ptr: *const wchar_t, end: *mut *mut wchar_t,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wcstoul(mut ptr: *const wchar_t, end: *mut *mut wchar_t, base: c_int) -> c_ulong {
+pub unsafe extern "C" fn wcstoul(
+    mut ptr: *const wchar_t,
+    end: *mut *mut wchar_t,
+    base: c_int,
+) -> c_ulong {
     skipws!(ptr);
     let result = strtou_impl!(c_ulong, ptr, base);
     if !end.is_null() {

src/header/wchar/utf8.rs

@@ -3,9 +3,10 @@
 
 use core::{char, slice, str, usize};
 
-use crate::header::errno;
-use crate::platform;
-use crate::platform::types::*;
+use crate::{
+    header::errno,
+    platform::{self, types::*},
+};
 
 use super::mbstate_t;
 

src/ld_so/linker.rs

@@ -1,19 +1,27 @@
-use alloc::boxed::Box;
-use alloc::collections::BTreeMap;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
+use alloc::{
+    boxed::Box,
+    collections::BTreeMap,
+    string::{String, ToString},
+    vec::Vec,
+};
 use core::{mem, ptr, slice};
-use goblin::elf::{program_header, reloc, sym, Elf};
-use goblin::error::{Error, Result};
-
-use crate::c_str::CString;
-use crate::fs::File;
-use crate::header::{fcntl, sys_mman, unistd};
-use crate::io::Read;
-use crate::platform::types::c_void;
-
-use super::tcb::{Master, Tcb};
-use super::PAGE_SIZE;
+use goblin::{
+    elf::{program_header, reloc, sym, Elf},
+    error::{Error, Result},
+};
+
+use crate::{
+    c_str::CString,
+    fs::File,
+    header::{fcntl, sys_mman, unistd},
+    io::Read,
+    platform::types::c_void,
+};
+
+use super::{
+    tcb::{Master, Tcb},
+    PAGE_SIZE,
+};
 
 #[cfg(target_os = "redox")]
 const PATH_SEP: char = ';';

src/ld_so/start.rs

@@ -1,8 +1,6 @@
 // Start code adapted from https://gitlab.redox-os.org/redox-os/relibc/blob/master/src/start.rs
 
-use crate::c_str::CStr;
-use crate::header::unistd;
-use crate::platform::types::c_char;
+use crate::{c_str::CStr, header::unistd, platform::types::c_char};
 
 use super::linker::Linker;
 use crate::start::Stack;

src/ld_so/tcb.rs

@@ -1,6 +1,5 @@
 use alloc::boxed::Box;
-use core::ops::Range;
-use core::{mem, ptr, slice};
+use core::{mem, ops::Range, ptr, slice};
 use goblin::error::{Error, Result};
 
 use crate::header::sys_mman;

src/platform/linux/epoll.rs

@@ -1,8 +1,8 @@
-use super::super::types::*;
-use super::super::PalEpoll;
-use super::{e, Sys};
-use crate::header::signal::sigset_t;
-use crate::header::sys_epoll::epoll_event;
+use super::{
+    super::{types::*, PalEpoll},
+    e, Sys,
+};
+use crate::header::{signal::sigset_t, sys_epoll::epoll_event};
 
 impl PalEpoll for Sys {
     fn epoll_create1(flags: c_int) -> c_int {

src/platform/linux/mod.rs

@@ -1,18 +1,19 @@
 use core::ptr;
 use core_io::Write;
 
-use super::types::*;
-use super::{errno, Pal};
-use crate::c_str::CStr;
-use crate::header::dirent::dirent;
-use crate::header::signal::SIGCHLD;
+use super::{errno, types::*, Pal};
+use crate::{
+    c_str::CStr,
+    header::{dirent::dirent, signal::SIGCHLD},
+};
 // use header::sys_resource::rusage;
-use crate::header::sys_stat::stat;
-use crate::header::sys_statvfs::statvfs;
-use crate::header::sys_time::{timeval, timezone};
+use crate::header::{
+    sys_stat::stat,
+    sys_statvfs::statvfs,
+    sys_time::{timeval, timezone},
+};
 // use header::sys_times::tms;
-use crate::header::sys_utsname::utsname;
-use crate::header::time::timespec;
+use crate::header::{sys_utsname::utsname, time::timespec};
 
 mod epoll;
 mod ptrace;

src/platform/linux/ptrace.rs

@@ -1,6 +1,7 @@
-use super::super::types::*;
-use super::super::PalPtrace;
-use super::{e, Sys};
+use super::{
+    super::{types::*, PalPtrace},
+    e, Sys,
+};
 
 impl PalPtrace for Sys {
     fn ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) -> c_int {

src/platform/linux/signal.rs

@@ -1,10 +1,13 @@
 use core::mem;
 
-use super::super::types::*;
-use super::super::PalSignal;
-use super::{e, Sys};
-use crate::header::signal::{sigaction, sigset_t, stack_t};
-use crate::header::sys_time::itimerval;
+use super::{
+    super::{types::*, PalSignal},
+    e, Sys,
+};
+use crate::header::{
+    signal::{sigaction, sigset_t, stack_t},
+    sys_time::itimerval,
+};
 
 impl PalSignal for Sys {
     fn getitimer(which: c_int, out: *mut itimerval) -> c_int {

src/platform/linux/socket.rs

@@ -1,6 +1,7 @@
-use super::super::types::*;
-use super::super::PalSocket;
-use super::{e, Sys};
+use super::{
+    super::{types::*, PalSocket},
+    e, Sys,
+};
 use crate::header::sys_socket::{sockaddr, socklen_t};
 
 impl PalSocket for Sys {

src/platform/mod.rs

@@ -1,6 +1,6 @@
+use crate::io::{self, Read, Write};
 use alloc::vec::Vec;
 use core::{fmt, ptr};
-use crate::io::{self, Read, Write};
 
 pub use self::allocator::*;
 

src/platform/pal/epoll.rs

@@ -1,7 +1,5 @@
-use super::super::types::*;
-use super::super::Pal;
-use crate::header::signal::sigset_t;
-use crate::header::sys_epoll::epoll_event;
+use super::super::{types::*, Pal};
+use crate::header::{signal::sigset_t, sys_epoll::epoll_event};
 
 pub trait PalEpoll: Pal {
     fn epoll_create1(flags: c_int) -> c_int;

src/platform/pal/mod.rs

@@ -1,11 +1,15 @@
 use super::types::*;
-use crate::c_str::CStr;
-use crate::header::dirent::dirent;
-use crate::header::sys_stat::stat;
-use crate::header::sys_statvfs::statvfs;
-use crate::header::sys_time::{timeval, timezone};
-use crate::header::sys_utsname::utsname;
-use crate::header::time::timespec;
+use crate::{
+    c_str::CStr,
+    header::{
+        dirent::dirent,
+        sys_stat::stat,
+        sys_statvfs::statvfs,
+        sys_time::{timeval, timezone},
+        sys_utsname::utsname,
+        time::timespec,
+    },
+};
 
 pub use self::epoll::PalEpoll;
 mod epoll;

src/platform/pal/ptrace.rs

@@ -1,5 +1,4 @@
-use super::super::types::*;
-use super::super::Pal;
+use super::super::{types::*, Pal};
 
 pub trait PalPtrace: Pal {
     fn ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) -> c_int;

src/platform/pal/signal.rs

@@ -1,7 +1,8 @@
-use super::super::types::*;
-use super::super::Pal;
-use crate::header::signal::{sigaction, sigset_t, stack_t};
-use crate::header::sys_time::itimerval;
+use super::super::{types::*, Pal};
+use crate::header::{
+    signal::{sigaction, sigset_t, stack_t},
+    sys_time::itimerval,
+};
 
 pub trait PalSignal: Pal {
     fn getitimer(which: c_int, out: *mut itimerval) -> c_int;

src/platform/pal/socket.rs

@@ -1,5 +1,4 @@
-use super::super::types::*;
-use super::super::Pal;
+use super::super::{types::*, Pal};
 use crate::header::sys_socket::{sockaddr, socklen_t};
 
 pub trait PalSocket: Pal {

src/platform/pte.rs

@@ -1,16 +1,20 @@
 #![allow(non_snake_case)]
 
-use alloc::boxed::Box;
-use alloc::collections::BTreeMap;
-use core::sync::atomic::{AtomicU32, Ordering};
-use core::{intrinsics, ptr};
-
-use crate::header::sys_mman;
-use crate::header::time::timespec;
-use crate::ld_so::tcb::{Master, Tcb};
-use crate::platform::types::{c_int, c_uint, c_void, pid_t, size_t};
-use crate::platform::{Pal, Sys};
-use crate::sync::Mutex;
+use alloc::{boxed::Box, collections::BTreeMap};
+use core::{
+    intrinsics, ptr,
+    sync::atomic::{AtomicU32, Ordering},
+};
+
+use crate::{
+    header::{sys_mman, time::timespec},
+    ld_so::tcb::{Master, Tcb},
+    platform::{
+        types::{c_int, c_uint, c_void, pid_t, size_t},
+        Pal, Sys,
+    },
+    sync::Mutex,
+};
 
 pub struct Semaphore {
     lock: Mutex<()>,

src/platform/redox/epoll.rs

@@ -1,17 +1,19 @@
-use super::super::types::*;
-use super::super::{Pal, PalEpoll};
-use super::Sys;
+use super::{
+    super::{types::*, Pal, PalEpoll},
+    Sys,
+};
 
+use crate::{
+    fs::File,
+    header::{errno::*, fcntl::*, signal::sigset_t, sys_epoll::*},
+    io::prelude::*,
+    platform,
+};
 use core::{mem, slice};
-use crate::fs::File;
-use crate::header::errno::*;
-use crate::header::fcntl::*;
-use crate::header::signal::sigset_t;
-use crate::header::sys_epoll::*;
-use crate::io::prelude::*;
-use crate::platform;
-use syscall::data::{Event, TimeSpec};
-use syscall::flag::EVENT_READ;
+use syscall::{
+    data::{Event, TimeSpec},
+    flag::EVENT_READ,
+};
 
 impl PalEpoll for Sys {
     fn epoll_create1(flags: c_int) -> c_int {
@@ -25,7 +27,8 @@ impl PalEpoll for Sys {
                     epfd,
                     &Event {
                         id: fd as usize,
-                        flags: syscall::EventFlags::from_bits(unsafe { (*event).events as usize }).expect("epoll: invalid bit pattern"),
+                        flags: syscall::EventFlags::from_bits(unsafe { (*event).events as usize })
+                            .expect("epoll: invalid bit pattern"),
                         // NOTE: Danger when using non 64-bit systems. If this is
                         // needed, use a box or something
                         data: unsafe { mem::transmute((*event).data) },

src/platform/redox/extra.rs

@@ -1,7 +1,6 @@
 use core::{ptr, slice};
 
-use crate::platform::sys::e;
-use crate::platform::types::*;
+use crate::platform::{sys::e, types::*};
 
 #[no_mangle]
 pub unsafe extern "C" fn redox_fpath(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t {

src/platform/redox/mod.rs

@@ -1,29 +1,30 @@
-use core::result::Result as CoreResult;
-use core::{mem, ptr, slice};
-use syscall::data::Map;
-use syscall::data::Stat as redox_stat;
-use syscall::data::StatVfs as redox_statvfs;
-use syscall::data::TimeSpec as redox_timespec;
-use syscall::{self, Result};
-
-use crate::c_str::{CStr, CString};
-use crate::fs::File;
-use crate::header::dirent::dirent;
-use crate::header::errno::{EINVAL, EIO, EPERM, ERANGE};
-use crate::header::fcntl;
-use crate::header::sys_mman::MAP_ANON;
-use crate::header::sys_stat::stat;
-use crate::header::sys_statvfs::statvfs;
-use crate::header::sys_time::{timeval, timezone};
-use crate::header::sys_wait;
-use crate::header::sys_utsname::{utsname, UTSLENGTH};
-use crate::header::time::timespec;
-use crate::header::unistd::{F_OK, R_OK, W_OK, X_OK};
-use crate::io::prelude::*;
-use crate::io::{self, BufReader, SeekFrom};
-
-use super::types::*;
-use super::{errno, Pal, Read};
+use core::{mem, ptr, result::Result as CoreResult, slice};
+use syscall::{
+    self,
+    data::{Map, Stat as redox_stat, StatVfs as redox_statvfs, TimeSpec as redox_timespec},
+    Result,
+};
+
+use crate::{
+    c_str::{CStr, CString},
+    fs::File,
+    header::{
+        dirent::dirent,
+        errno::{EINVAL, EIO, EPERM, ERANGE},
+        fcntl,
+        sys_mman::MAP_ANON,
+        sys_stat::stat,
+        sys_statvfs::statvfs,
+        sys_time::{timeval, timezone},
+        sys_utsname::{utsname, UTSLENGTH},
+        sys_wait,
+        time::timespec,
+        unistd::{F_OK, R_OK, W_OK, X_OK},
+    },
+    io::{self, prelude::*, BufReader, SeekFrom},
+};
+
+use super::{errno, types::*, Pal, Read};
 
 mod epoll;
 mod extra;
@@ -414,7 +415,7 @@ impl Pal for Sys {
 
     fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char {
         let buf_slice = unsafe { slice::from_raw_parts_mut(buf as *mut u8, size as usize) };
-        if ! buf_slice.is_empty() {
+        if !buf_slice.is_empty() {
             let nonnull_size = buf_slice.len() - 1;
             let read = e(syscall::getcwd(&mut buf_slice[..nonnull_size]));
             if read == !0 {
@@ -631,7 +632,9 @@ impl Pal for Sys {
         let map = Map {
             offset: off as usize,
             size: len,
-            flags: syscall::MapFlags::from_bits_truncate(((prot as usize) << 16) | ((flags as usize) & 0xFFFF)),
+            flags: syscall::MapFlags::from_bits_truncate(
+                ((prot as usize) << 16) | ((flags as usize) & 0xFFFF),
+            ),
         };
 
         if flags & MAP_ANON == MAP_ANON {
@@ -657,7 +660,8 @@ impl Pal for Sys {
         e(syscall::mprotect(
             addr as usize,
             len,
-            syscall::MapFlags::from_bits((prot as usize) << 16).expect("mprotect: invalid bit pattern")
+            syscall::MapFlags::from_bits((prot as usize) << 16)
+                .expect("mprotect: invalid bit pattern"),
         )) as c_int
     }
 
@@ -928,11 +932,14 @@ impl Pal for Sys {
         let mut res = None;
         let mut status = 0;
 
-        let inner = |status: &mut usize, flags| syscall::waitpid(
-            pid as usize,
-            status,
-            syscall::WaitFlags::from_bits(flags as usize).expect("waitpid: invalid bit pattern")
-        );
+        let inner = |status: &mut usize, flags| {
+            syscall::waitpid(
+                pid as usize,
+                status,
+                syscall::WaitFlags::from_bits(flags as usize)
+                    .expect("waitpid: invalid bit pattern"),
+            )
+        };
 
         // First, allow ptrace to handle waitpid
         // TODO: Handle special PIDs here (such as -1)
@@ -940,8 +947,12 @@ impl Pal for Sys {
         let mut sessions = state.sessions.lock();
         if let Ok(session) = ptrace::get_session(&mut sessions, pid) {
             if options & sys_wait::WNOHANG != sys_wait::WNOHANG {
-                let _ = (&mut &session.tracer).write(&syscall::PTRACE_FLAG_WAIT.bits().to_ne_bytes());
-                res = Some(e(inner(&mut status, options | sys_wait::WNOHANG | sys_wait::WUNTRACED)));
+                let _ =
+                    (&mut &session.tracer).write(&syscall::PTRACE_FLAG_WAIT.bits().to_ne_bytes());
+                res = Some(e(inner(
+                    &mut status,
+                    options | sys_wait::WNOHANG | sys_wait::WUNTRACED,
+                )));
                 if res == Some(0) {
                     // WNOHANG, just pretend ptrace SIGSTOP:ped this
                     status = (syscall::SIGSTOP << 8) | 0x7f;

src/platform/redox/ptrace.rs

@@ -4,16 +4,15 @@
 //! we are NOT going to bend our API for the sake of
 //! compatibility. So, this module will be a hellhole.
 
-use super::super::types::*;
-use super::super::{errno, Pal, PalPtrace, PalSignal, Sys};
-use crate::c_str::CString;
-use crate::fs::File;
-use crate::header::sys_user::user_regs_struct;
-use crate::header::{errno as errnoh, fcntl, signal, sys_ptrace};
-use crate::io::{self, prelude::*};
-use crate::sync::{Mutex, Once};
-use alloc::collections::BTreeMap;
-use alloc::collections::btree_map::Entry;
+use super::super::{errno, types::*, Pal, PalPtrace, PalSignal, Sys};
+use crate::{
+    c_str::CString,
+    fs::File,
+    header::{errno as errnoh, fcntl, signal, sys_ptrace, sys_user::user_regs_struct},
+    io::{self, prelude::*},
+    sync::{Mutex, Once},
+};
+use alloc::collections::{btree_map::Entry, BTreeMap};
 use core::mem;
 use syscall;
 
@@ -21,15 +20,15 @@ pub struct Session {
     pub tracer: File,
     pub mem: File,
     pub regs: File,
-    pub fpregs: File
+    pub fpregs: File,
 }
 pub struct State {
-    pub sessions: Mutex<BTreeMap<pid_t, Session>>
+    pub sessions: Mutex<BTreeMap<pid_t, Session>>,
 }
 impl State {
     fn new() -> Self {
         Self {
-            sessions: Mutex::new(BTreeMap::new())
+            sessions: Mutex::new(BTreeMap::new()),
         }
     }
 }
@@ -40,28 +39,53 @@ pub fn init_state() -> &'static State {
     STATE.call_once(|| State::new())
 }
 pub fn is_traceme(pid: pid_t) -> bool {
-    File::open(&CString::new(format!("chan:ptrace-relibc/{}/traceme", pid)).unwrap(), fcntl::O_PATH).is_ok()
+    File::open(
+        &CString::new(format!("chan:ptrace-relibc/{}/traceme", pid)).unwrap(),
+        fcntl::O_PATH,
+    )
+    .is_ok()
 }
 pub fn get_session(sessions: &mut BTreeMap<pid_t, Session>, pid: pid_t) -> io::Result<&Session> {
     const NEW_FLAGS: c_int = fcntl::O_RDWR | fcntl::O_CLOEXEC;
 
     match sessions.entry(pid) {
-        Entry::Vacant(entry) => if is_traceme(pid) {
-            Ok(entry.insert(Session {
-                tracer: File::open(&CString::new(format!("proc:{}/trace", pid)).unwrap(), NEW_FLAGS | fcntl::O_NONBLOCK)?,
-                mem: File::open(&CString::new(format!("proc:{}/mem", pid)).unwrap(), NEW_FLAGS)?,
-                regs: File::open(&CString::new(format!("proc:{}/regs/int", pid)).unwrap(), NEW_FLAGS)?,
-                fpregs: File::open(&CString::new(format!("proc:{}/regs/float", pid)).unwrap(), NEW_FLAGS)?,
-            }))
-        } else {
-            unsafe { errno = errnoh::ESRCH; }
-            Err(io::last_os_error())
-        },
-        Entry::Occupied(entry) => Ok(entry.into_mut())
+        Entry::Vacant(entry) => {
+            if is_traceme(pid) {
+                Ok(entry.insert(Session {
+                    tracer: File::open(
+                        &CString::new(format!("proc:{}/trace", pid)).unwrap(),
+                        NEW_FLAGS | fcntl::O_NONBLOCK,
+                    )?,
+                    mem: File::open(
+                        &CString::new(format!("proc:{}/mem", pid)).unwrap(),
+                        NEW_FLAGS,
+                    )?,
+                    regs: File::open(
+                        &CString::new(format!("proc:{}/regs/int", pid)).unwrap(),
+                        NEW_FLAGS,
+                    )?,
+                    fpregs: File::open(
+                        &CString::new(format!("proc:{}/regs/float", pid)).unwrap(),
+                        NEW_FLAGS,
+                    )?,
+                }))
+            } else {
+                unsafe {
+                    errno = errnoh::ESRCH;
+                }
+                Err(io::last_os_error())
+            }
+        }
+        Entry::Occupied(entry) => Ok(entry.into_mut()),
     }
 }
 
-fn inner_ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) -> io::Result<c_int> {
+fn inner_ptrace(
+    request: c_int,
+    pid: pid_t,
+    addr: *mut c_void,
+    data: *mut c_void,
+) -> io::Result<c_int> {
     let state = init_state();
 
     if request == sys_ptrace::PTRACE_TRACEME {
@@ -69,7 +93,7 @@ fn inner_ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void
         let pid = Sys::getpid();
         mem::forget(File::open(
             &CString::new(format!("chan:ptrace-relibc/{}/traceme", pid)).unwrap(),
-            fcntl::O_CREAT | fcntl::O_PATH | fcntl::O_EXCL
+            fcntl::O_CREAT | fcntl::O_PATH | fcntl::O_EXCL,
         )?);
         return Ok(0);
     }
@@ -78,23 +102,31 @@ fn inner_ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void
     let session = get_session(&mut sessions, pid)?;
 
     match request {
-        sys_ptrace::PTRACE_CONT | sys_ptrace::PTRACE_SINGLESTEP |
-        sys_ptrace::PTRACE_SYSCALL | sys_ptrace::PTRACE_SYSEMU |
-        sys_ptrace::PTRACE_SYSEMU_SINGLESTEP => {
+        sys_ptrace::PTRACE_CONT
+        | sys_ptrace::PTRACE_SINGLESTEP
+        | sys_ptrace::PTRACE_SYSCALL
+        | sys_ptrace::PTRACE_SYSEMU
+        | sys_ptrace::PTRACE_SYSEMU_SINGLESTEP => {
             Sys::kill(pid, signal::SIGCONT as _);
 
             // TODO: Translate errors
-            let syscall = syscall::PTRACE_STOP_PRE_SYSCALL.bits() | syscall::PTRACE_STOP_POST_SYSCALL.bits();
-            (&mut &session.tracer).write(&match request {
-                sys_ptrace::PTRACE_CONT => 0,
-                sys_ptrace::PTRACE_SINGLESTEP => syscall::PTRACE_STOP_SINGLESTEP.bits(),
-                sys_ptrace::PTRACE_SYSCALL => syscall,
-                sys_ptrace::PTRACE_SYSEMU => syscall::PTRACE_FLAG_SYSEMU.bits() | syscall,
-                sys_ptrace::PTRACE_SYSEMU_SINGLESTEP => syscall::PTRACE_FLAG_SYSEMU.bits() | syscall::PTRACE_STOP_SINGLESTEP.bits(),
-                _ => unreachable!("unhandled ptrace request type {}", request)
-            }.to_ne_bytes())?;
+            let syscall =
+                syscall::PTRACE_STOP_PRE_SYSCALL.bits() | syscall::PTRACE_STOP_POST_SYSCALL.bits();
+            (&mut &session.tracer).write(
+                &match request {
+                    sys_ptrace::PTRACE_CONT => 0,
+                    sys_ptrace::PTRACE_SINGLESTEP => syscall::PTRACE_STOP_SINGLESTEP.bits(),
+                    sys_ptrace::PTRACE_SYSCALL => syscall,
+                    sys_ptrace::PTRACE_SYSEMU => syscall::PTRACE_FLAG_SYSEMU.bits() | syscall,
+                    sys_ptrace::PTRACE_SYSEMU_SINGLESTEP => {
+                        syscall::PTRACE_FLAG_SYSEMU.bits() | syscall::PTRACE_STOP_SINGLESTEP.bits()
+                    }
+                    _ => unreachable!("unhandled ptrace request type {}", request),
+                }
+                .to_ne_bytes(),
+            )?;
             Ok(0)
-        },
+        }
         sys_ptrace::PTRACE_GETREGS => {
             let c_regs = unsafe { &mut *(data as *mut user_regs_struct) };
             let mut redox_regs = syscall::IntRegisters::default();
@@ -123,13 +155,13 @@ fn inner_ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void
                 ss: redox_regs.ss as _,
                 fs_base: 0, // fs_base: redox_regs.fs_base as _,
                 gs_base: 0, // gs_base: redox_regs.gs_base as _,
-                ds: 0, // ds: redox_regs.ds as _,
-                es: 0, // es: redox_regs.es as _,
+                ds: 0,      // ds: redox_regs.ds as _,
+                es: 0,      // es: redox_regs.es as _,
                 fs: redox_regs.fs as _,
                 gs: 0, // gs: redox_regs.gs as _,
             };
             Ok(0)
-        },
+        }
         sys_ptrace::PTRACE_SETREGS => {
             let c_regs = unsafe { &*(data as *mut user_regs_struct) };
             let redox_regs = syscall::IntRegisters {
@@ -163,8 +195,8 @@ fn inner_ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void
             };
             (&mut &session.regs).write(&redox_regs)?;
             Ok(0)
-        },
-        _ => unimplemented!()
+        }
+        _ => unimplemented!(),
     }
 }
 

src/platform/redox/signal.rs

@@ -1,13 +1,18 @@
 use core::mem;
 use syscall;
 
-use super::super::types::*;
-use super::super::{Pal, PalSignal};
-use super::{e, Sys};
-use crate::header::errno::EINVAL;
-use crate::header::signal::{sigaction, sigset_t, stack_t};
-use crate::header::sys_time::{itimerval, ITIMER_REAL};
-use crate::platform::errno;
+use super::{
+    super::{types::*, Pal, PalSignal},
+    e, Sys,
+};
+use crate::{
+    header::{
+        errno::EINVAL,
+        signal::{sigaction, sigset_t, stack_t},
+        sys_time::{itimerval, ITIMER_REAL},
+    },
+    platform::errno,
+};
 
 impl PalSignal for Sys {
     fn getitimer(which: c_int, out: *mut itimerval) -> c_int {

src/platform/redox/socket.rs

@@ -1,14 +1,15 @@
 use core::{mem, ptr, slice};
-use syscall::flag::*;
-use syscall::{self, Result};
-
-use super::super::types::*;
-use super::super::{errno, Pal, PalSocket};
-use super::{e, Sys};
-use crate::header::netinet_in::{in_port_t, sockaddr_in};
-use crate::header::sys_socket::constants::*;
-use crate::header::sys_socket::{sockaddr, socklen_t};
-use crate::header::sys_time::timeval;
+use syscall::{self, flag::*, Result};
+
+use super::{
+    super::{errno, types::*, Pal, PalSocket},
+    e, Sys,
+};
+use crate::header::{
+    netinet_in::{in_port_t, sockaddr_in},
+    sys_socket::{constants::*, sockaddr, socklen_t},
+    sys_time::timeval,
+};
 
 macro_rules! bind_or_connect {
     (bind $path:expr) => {
@@ -146,11 +147,7 @@ impl PalSocket for Sys {
     ) -> c_int {
         eprintln!(
             "getsockopt({}, {}, {}, {:p}, {:p})",
-            socket,
-            level,
-            option_name,
-            option_value,
-            option_len
+            socket, level, option_name, option_value, option_len
         );
         e(Err(syscall::Error::new(syscall::ENOSYS))) as c_int
     }
@@ -244,7 +241,11 @@ impl PalSocket for Sys {
 
             let _ = syscall::close(fd);
 
-            if ret >= 0 { 0 } else { -1 }
+            if ret >= 0 {
+                0
+            } else {
+                -1
+            }
         };
 
         match level {
@@ -253,26 +254,18 @@ impl PalSocket for Sys {
                 SO_SNDTIMEO => return set_timeout(b"write_timeout"),
                 _ => (),
             },
-            _ => ()
+            _ => (),
         }
 
         eprintln!(
             "setsockopt({}, {}, {}, {:p}, {})",
-            socket,
-            level,
-            option_name,
-            option_value,
-            option_len
+            socket, level, option_name, option_value, option_len
         );
         e(Err(syscall::Error::new(syscall::ENOSYS))) as c_int
     }
 
     fn shutdown(socket: c_int, how: c_int) -> c_int {
-        eprintln!(
-            "shutdown({}, {})",
-            socket,
-            how
-        );
+        eprintln!("shutdown({}, {})", socket, how);
         e(Err(syscall::Error::new(syscall::ENOSYS))) as c_int
     }
 

src/platform/rlb.rs

@@ -1,7 +1,6 @@
 use alloc::vec::Vec;
 
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::platform::{types::*, Pal, Sys};
 
 use crate::header::unistd::{lseek, SEEK_SET};
 /// Implements an `Iterator` which returns on either newline or EOF.

src/start.rs

@@ -1,11 +1,11 @@
 use alloc::vec::Vec;
 use core::{intrinsics, ptr};
 
-use crate::header::{stdio, stdlib};
-use crate::ld_so;
-use crate::platform;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::{
+    header::{stdio, stdlib},
+    ld_so,
+    platform::{self, types::*, Pal, Sys},
+};
 
 #[repr(C)]
 pub struct Stack {

src/sync/mod.rs

@@ -1,15 +1,17 @@
 pub mod mutex;
 pub mod once;
 
-pub use self::mutex::{Mutex, MutexGuard};
-pub use self::once::Once;
+pub use self::{
+    mutex::{Mutex, MutexGuard},
+    once::Once,
+};
 
-use core::cell::UnsafeCell;
-use core::ops::Deref;
-use core::sync::atomic;
-use core::sync::atomic::AtomicI32 as AtomicInt;
-use crate::platform::types::*;
-use crate::platform::{Pal, Sys};
+use crate::platform::{types::*, Pal, Sys};
+use core::{
+    cell::UnsafeCell,
+    ops::Deref,
+    sync::atomic::{self, AtomicI32 as AtomicInt},
+};
 
 const FUTEX_WAIT: c_int = 0;
 const FUTEX_WAKE: c_int = 1;

src/sync/mutex.rs

@@ -1,8 +1,10 @@
 use super::{AtomicLock, AttemptStatus};
-use core::cell::UnsafeCell;
-use core::ops::{Deref, DerefMut};
-use core::sync::atomic::Ordering::SeqCst;
 use crate::platform::types::*;
+use core::{
+    cell::UnsafeCell,
+    ops::{Deref, DerefMut},
+    sync::atomic::Ordering::SeqCst,
+};
 
 const UNLOCKED: c_int = 0;
 const LOCKED: c_int = 1;

src/sync/once.rs

@@ -1,8 +1,6 @@
 use super::{AtomicLock, AttemptStatus};
-use core::cell::UnsafeCell;
-use core::mem::MaybeUninit;
-use core::sync::atomic::Ordering::SeqCst;
 use crate::platform::types::*;
+use core::{cell::UnsafeCell, mem::MaybeUninit, sync::atomic::Ordering::SeqCst};
 
 const UNINITIALIZED: c_int = 0;
 const INITIALIZING: c_int = 1;