Clippy fixes

src/c_str.rs

@@ -682,7 +682,7 @@ impl fmt::Debug for CStr {
 
 impl<'a> Default for &'a CStr {
     fn default() -> &'a CStr {
-        const SLICE: &'static [c_char] = &[0];
+        const SLICE: &[c_char] = &[0];
         unsafe { CStr::from_ptr(SLICE.as_ptr()) }
     }
 }

src/cxa.rs

@@ -15,9 +15,9 @@ pub unsafe extern "C" fn __cxa_atexit(
     arg: *mut c_void,
     dso: *mut c_void,
 ) -> c_int {
-    for i in 0..CXA_ATEXIT_FUNCS.len() {
-        if CXA_ATEXIT_FUNCS[i].is_none() {
-            CXA_ATEXIT_FUNCS[i] = func_opt.map(|func| CxaAtExitFunc { func, arg, dso });
+    for item in &mut CXA_ATEXIT_FUNCS {
+        if item.is_none() {
+            *item = func_opt.map(|func| CxaAtExitFunc { func, arg, dso });
             return 0;
         }
     }

src/header/arpa_inet/mod.rs

@@ -101,10 +101,10 @@ pub unsafe extern "C" fn inet_ntop(
 }
 
 #[no_mangle]
-pub extern "C" fn inet_addr(cp: *const c_char) -> in_addr_t {
+pub unsafe extern "C" fn inet_addr(cp: *const c_char) -> in_addr_t {
     let mut val: in_addr = in_addr { s_addr: 0 };
 
-    if unsafe { inet_aton(cp, &mut val) } > 0 {
+    if inet_aton(cp, &mut val) > 0 {
         val.s_addr
     } else {
         INADDR_NONE
@@ -114,7 +114,7 @@ pub extern "C" fn inet_addr(cp: *const c_char) -> in_addr_t {
 #[no_mangle]
 pub extern "C" fn inet_lnaof(input: in_addr) -> in_addr_t {
     if input.s_addr >> 24 < 128 {
-        input.s_addr & 0xffffff
+        input.s_addr & 0xff_ffff
     } else if input.s_addr >> 24 < 192 {
         input.s_addr & 0xffff
     } else {
@@ -140,7 +140,7 @@ pub extern "C" fn inet_makeaddr(net: in_addr_t, host: in_addr_t) -> in_addr {
 #[no_mangle]
 pub extern "C" fn inet_netof(input: in_addr) -> in_addr_t {
     if input.s_addr >> 24 < 128 {
-        input.s_addr & 0xffffff
+        input.s_addr & 0xff_ffff
     } else if input.s_addr >> 24 < 192 {
         input.s_addr & 0xffff
     } else {
@@ -149,6 +149,6 @@ pub extern "C" fn inet_netof(input: in_addr) -> in_addr_t {
 }
 
 #[no_mangle]
-pub extern "C" fn inet_network(cp: *mut c_char) -> in_addr_t {
+pub unsafe extern "C" fn inet_network(cp: *mut c_char) -> in_addr_t {
     ntohl(inet_addr(cp))
 }

src/header/assert/mod.rs

@@ -16,9 +16,9 @@ pub unsafe extern "C" fn __assert(
     let file = CStr::from_ptr(file).to_str().unwrap();
     let cond = CStr::from_ptr(cond).to_str().unwrap();
 
-    write!(
+    writeln!(
         *stdio::stderr,
-        "{}: {}:{}: Assertion `{}` failed.\n",
+        "{}: {}:{}: Assertion `{}` failed.",
         func,
         file,
         line,

src/header/dirent/mod.rs

@@ -36,8 +36,8 @@ pub struct dirent {
 }
 
 #[no_mangle]
-pub extern "C" fn opendir(path: *const c_char) -> *mut DIR {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn opendir(path: *const c_char) -> *mut DIR {
+    let path = CStr::from_ptr(path);
     let file = match File::open(
         path,
         fcntl::O_RDONLY | fcntl::O_DIRECTORY | fcntl::O_CLOEXEC,
@@ -86,7 +86,7 @@ pub unsafe extern "C" fn readdir(dir: *mut DIR) -> *mut dirent {
         (*dir).len = read as usize;
     }
 
-    let ptr = (*dir).buf.as_mut_ptr().offset((*dir).index as isize) as *mut dirent;
+    let ptr = (*dir).buf.as_mut_ptr().add((*dir).index) as *mut dirent;
 
     (*dir).offset = (*ptr).d_off as usize;
     (*dir).index += (*ptr).d_reclen as usize;

src/header/fcntl/mod.rs

@@ -30,7 +30,7 @@ pub const F_WRLCK: c_int = 1;
 pub const F_UNLCK: c_int = 2;
 
 #[no_mangle]
-pub extern "C" fn creat(path: *const c_char, mode: mode_t) -> c_int {
+pub unsafe extern "C" fn creat(path: *const c_char, mode: mode_t) -> c_int {
     sys_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode)
 }
 
@@ -40,7 +40,7 @@ pub extern "C" fn sys_fcntl(fildes: c_int, cmd: c_int, arg: c_int) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn sys_open(path: *const c_char, oflag: c_int, mode: mode_t) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn sys_open(path: *const c_char, oflag: c_int, mode: mode_t) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::open(path, oflag, mode)
 }

src/header/fnmatch/mod.rs

@@ -95,10 +95,8 @@ unsafe fn tokenize(mut pattern: *const u8, flags: c_int) -> Vec<(Token, Range)>
                                 list.push(Collation::Char(c));
                             }
                         }
-                    } else {
-                        if can_push(was_leading, flags, c) {
-                            list.push(Collation::Char(c));
-                        }
+                    } else if can_push(was_leading, flags, c) {
+                        list.push(Collation::Char(c));
                     }
                 }
                 // Otherwise, there was no closing ]. Maybe error?

src/header/getopt/mod.rs

@@ -47,7 +47,7 @@ pub unsafe extern "C" fn getopt_long(
                 || *current_arg.offset(1) == 0
             {
                 -1
-            } else if string::strcmp(current_arg, b"--\0".as_ptr() as _) == 0 {
+            } else if string::strcmp(current_arg, c_str!("--").as_ptr()) == 0 {
                 optind += 1;
                 -1
             } else {
@@ -85,22 +85,20 @@ pub unsafe extern "C" fn getopt_long(
                                 } else if optind < argc {
                                     optarg = *argv.offset(optind as isize);
                                     optind += 1;
+                                } else if *optstring == b':' as c_char {
+                                    return b':' as c_int;
                                 } else {
-                                    if *optstring == b':' as c_char {
-                                        return b':' as c_int;
-                                    } else {
-                                        stdio::fputs(*argv as _, &mut *stdio::stderr);
-                                        stdio::fputs(
-                                            ": option '--\0".as_ptr() as _,
-                                            &mut *stdio::stderr,
-                                        );
-                                        stdio::fputs(current_arg, &mut *stdio::stderr);
-                                        stdio::fputs(
-                                            "' requires an argument\n\0".as_ptr() as _,
-                                            &mut *stdio::stderr,
-                                        );
-                                        return b'?' as c_int;
-                                    }
+                                    stdio::fputs(*argv as _, &mut *stdio::stderr);
+                                    stdio::fputs(
+                                        ": option '--\0".as_ptr() as _,
+                                        &mut *stdio::stderr,
+                                    );
+                                    stdio::fputs(current_arg, &mut *stdio::stderr);
+                                    stdio::fputs(
+                                        "' requires an argument\n\0".as_ptr() as _,
+                                        &mut *stdio::stderr,
+                                    );
+                                    return b'?' as c_int;
                                 }
                             }
 

src/header/libgen/mod.rs

@@ -1,14 +1,12 @@
 //! libgen implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/libgen.h.html
 
-use core::ptr;
-
 use platform::types::c_char;
 
 use header::string::strlen;
 
 #[no_mangle]
 pub unsafe extern "C" fn basename(str: *mut c_char) -> *mut c_char {
-    if str == ptr::null_mut() || strlen(str) == 0 {
+    if str.is_null() || strlen(str) == 0 {
         return ".\0".as_ptr() as *mut c_char;
     }
     let mut end = strlen(str) as isize - 1;
@@ -23,12 +21,12 @@ pub unsafe extern "C" fn basename(str: *mut c_char) -> *mut c_char {
         begin -= 1;
     }
     *str.offset(end + 1) = 0;
-    return str.offset(begin + 1) as *mut c_char;
+    str.offset(begin + 1) as *mut c_char
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn dirname(str: *mut c_char) -> *mut c_char {
-    if str == ptr::null_mut() || strlen(str) == 0 {
+    if str.is_null() || strlen(str) == 0 {
         return ".\0".as_ptr() as *mut c_char;
     }
     let mut end = strlen(str) as isize - 1;
@@ -45,5 +43,5 @@ pub unsafe extern "C" fn dirname(str: *mut c_char) -> *mut c_char {
         return ".\0".as_ptr() as *mut c_char;
     }
     *str.offset(end + 1) = 0;
-    return str;
+    str
 }

src/header/netdb/dns/mod.rs

@@ -98,7 +98,7 @@ impl Dns {
     }
 
     pub fn parse(data: &[u8]) -> Result<Self, String> {
-        let name_ind = 0b11000000;
+        let name_ind = 0b1100_0000;
         let mut i = 0;
 
         macro_rules! pop_u8 {
@@ -194,10 +194,10 @@ impl Dns {
         }
 
         Ok(Dns {
-            transaction_id: transaction_id,
-            flags: flags,
-            queries: queries,
-            answers: answers,
+            transaction_id,
+            flags,
+            queries,
+            answers,
         })
     }
 }

src/header/netdb/mod.rs

@@ -269,7 +269,7 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
 
     let dns_vec: Vec<u8> = dns_string
         .trim()
-        .split(".")
+        .split('.')
         .map(|octet| octet.parse::<u8>().unwrap_or(0))
         .collect();
 
@@ -362,7 +362,7 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
                         // subsection of the domain.
                         // We need to parse this to insert periods where
                         // they belong (ie at the end of each string)
-                        let data = parse_revdns_answer(answer.data.clone());
+                        let data = parse_revdns_answer(&answer.data);
                         names.push(data);
                     }
                 }
@@ -375,14 +375,14 @@ fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>, c_int> {
     }
 }
 
-fn parse_revdns_answer(data: Vec<u8>) -> Vec<u8> {
+fn parse_revdns_answer(data: &[u8]) -> Vec<u8> {
     let mut cursor = 0;
     let mut index = 0;
-    let mut output = data.clone();
+    let mut output = data.to_vec();
     while index < data.len() - 1 {
         let offset = data[index] as usize;
         index = cursor + offset + 1;
-        output[index] = '.' as u8;
+        output[index] = b'.';
         cursor = index;
     }
     //we don't want an extra period at the end
@@ -427,7 +427,7 @@ pub unsafe extern "C" fn gethostbyaddr(
     sethostent(HOST_STAYOPEN);
     while {
         p = gethostent();
-        p != ptr::null()
+        !p.is_null()
     } {
         let mut cp = (*p).h_addr_list;
         loop {
@@ -472,7 +472,7 @@ pub unsafe extern "C" fn gethostbyaddr(
         }
         Err(e) => {
             platform::errno = e;
-            return ptr::null();
+            ptr::null()
         }
     }
 }
@@ -484,9 +484,9 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
     let mut octets = str::from_utf8_unchecked(name_cstr.to_bytes()).split('.');
     let mut s_addr = [0u8; 4];
     let mut is_addr = true;
-    for i in 0..4 {
+    for item in &mut s_addr {
         if let Some(n) = octets.next().and_then(|x| u8::from_str(x).ok()) {
-            s_addr[i] = n;
+            *item = n;
         } else {
             is_addr = false;
         }
@@ -495,7 +495,7 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
         is_addr = false;
     }
 
-    if is_addr == true {
+    if is_addr {
         let addr = in_addr {
             s_addr: mem::transmute::<[u8; 4], u32>(s_addr),
         };
@@ -507,7 +507,7 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *const hostent {
     sethostent(HOST_STAYOPEN);
     while {
         p = gethostent();
-        p != ptr::null()
+        !p.is_null()
     } {
         if strcasecmp((*p).h_name, name) == 0 {
             sethostent(HOST_STAYOPEN);
@@ -580,7 +580,7 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
     rlb.seek(H_POS);
 
     let mut r: Box<str> = Box::default();
-    while r.is_empty() || r.split_whitespace().next() == None || r.starts_with("#") {
+    while r.is_empty() || r.split_whitespace().next() == None || r.starts_with('#') {
         r = match rlb.next() {
             Line::Some(s) => bytes_to_box_str(s),
             _ => {
@@ -612,11 +612,8 @@ pub unsafe extern "C" fn gethostent() -> *const hostent {
 
     let mut _host_aliases: Vec<Vec<u8>> = Vec::new();
 
-    loop {
-        let mut alias = match iter.next() {
-            Some(s) => s.as_bytes().to_vec(),
-            _ => break,
-        };
+    while let Some(s) = iter.next() {
+        let mut alias = s.as_bytes().to_vec();
         alias.push(b'\0');
         _host_aliases.push(alias);
     }
@@ -665,7 +662,7 @@ pub unsafe extern "C" fn getprotobyname(name: *const c_char) -> *const protoent
     setprotoent(PROTO_STAYOPEN);
     while {
         p = getprotoent();
-        p != ptr::null()
+        !p.is_null()
     } {
         if strcasecmp((*p).p_name, name) == 0 {
             setprotoent(PROTO_STAYOPEN);
@@ -674,11 +671,11 @@ pub unsafe extern "C" fn getprotobyname(name: *const c_char) -> *const protoent
 
         let mut cp = (*p).p_aliases;
         loop {
-            if cp == ptr::null_mut() {
+            if cp.is_null() {
                 setprotoent(PROTO_STAYOPEN);
                 break;
             }
-            if (*cp) == ptr::null_mut() {
+            if (*cp).is_null() {
                 setprotoent(PROTO_STAYOPEN);
                 break;
             }
@@ -701,7 +698,7 @@ pub unsafe extern "C" fn getprotobynumber(number: c_int) -> *const protoent {
     let mut p: *const protoent;
     while {
         p = getprotoent();
-        p != ptr::null()
+        !p.is_null()
     } {
         if (*p).p_proto == number {
             setprotoent(PROTO_STAYOPEN);
@@ -723,7 +720,7 @@ pub unsafe extern "C" fn getprotoent() -> *const protoent {
     rlb.seek(P_POS);
 
     let mut r: Box<str> = Box::default();
-    while r.is_empty() || r.split_whitespace().next() == None || r.starts_with("#") {
+    while r.is_empty() || r.split_whitespace().next() == None || r.starts_with('#') {
         r = match rlb.next() {
             Line::Some(s) => bytes_to_box_str(s),
             _ => {
@@ -747,11 +744,8 @@ pub unsafe extern "C" fn getprotoent() -> *const protoent {
     PROTO_NUM = Some(atoi(num.as_mut_slice().as_mut_ptr() as *mut i8));
 
     let mut _proto_aliases: Vec<Vec<u8>> = Vec::new();
-    loop {
-        let mut alias = match iter.next() {
-            Some(s) => s.as_bytes().to_vec(),
-            None => break,
-        };
+    while let Some(s) = iter.next() {
+        let mut alias = s.as_bytes().to_vec();
         alias.push(b'\0');
         _proto_aliases.push(alias);
     }
@@ -785,7 +779,7 @@ pub unsafe extern "C" fn getservbyname(
     if proto.is_null() {
         while {
             p = getservent();
-            p != ptr::null()
+            !p.is_null()
         } {
             if strcasecmp((*p).s_name, name) == 0 {
                 setservent(SERV_STAYOPEN);
@@ -795,7 +789,7 @@ pub unsafe extern "C" fn getservbyname(
     } else {
         while {
             p = getservent();
-            p != ptr::null()
+            !p.is_null()
         } {
             if strcasecmp((*p).s_name, name) == 0 && strcasecmp((*p).s_proto, proto) == 0 {
                 setservent(SERV_STAYOPEN);
@@ -815,7 +809,7 @@ pub unsafe extern "C" fn getservbyport(port: c_int, proto: *const c_char) -> *co
     if proto.is_null() {
         while {
             p = getservent();
-            p != ptr::null()
+            !p.is_null()
         } {
             if (*p).s_port == port {
                 setservent(SERV_STAYOPEN);
@@ -825,7 +819,7 @@ pub unsafe extern "C" fn getservbyport(port: c_int, proto: *const c_char) -> *co
     } else {
         while {
             p = getservent();
-            p != ptr::null()
+            !p.is_null()
         } {
             if (*p).s_port == port && strcasecmp((*p).s_proto, proto) == 0 {
                 setservent(SERV_STAYOPEN);
@@ -869,7 +863,7 @@ pub unsafe extern "C" fn getservent() -> *const servent {
             Some(port_proto) => port_proto,
             None => continue,
         };
-        let mut split = port_proto.split("/");
+        let mut split = port_proto.split('/');
         let mut port = match split.next() {
             Some(port) => port.as_bytes().to_vec(),
             None => continue,

src/header/netinet_in/mod.rs

@@ -55,11 +55,11 @@ pub const IPPROTO_RAW: u8 = 0xff;
 pub const IPPROTO_MAX: u8 = 0xff;
 
 pub const INADDR_ANY: u32 = 0; // Can't use in_addr_t alias because cbindgen :(
-pub const INADDR_BROADCAST: u32 = 0xFFFFFFFF; // Can't use core::u32::MAX because cbindgen :(
-pub const INADDR_NONE: u32 = 0xFFFFFFFF;
-pub const INADDR_LOOPBACK: u32 = 0x7F000001;
+pub const INADDR_BROADCAST: u32 = 0xFFFF_FFFF; // Can't use core::u32::MAX because cbindgen :(
+pub const INADDR_NONE: u32 = 0xFFFF_FFFF;
+pub const INADDR_LOOPBACK: u32 = 0x7F00_0001;
 
-pub const INADDR_UNSPEC_GROUP: u32 = 0xE0000000;
-pub const INADDR_ALLHOSTS_GROUP: u32 = 0xE0000001;
-pub const INADDR_ALLRTRS_GROUP: u32 = 0xE0000002;
-pub const INADDR_MAX_LOCAL_GROUP: u32 = 0xE00000FF;
+pub const INADDR_UNSPEC_GROUP: u32 = 0xE000_0000;
+pub const INADDR_ALLHOSTS_GROUP: u32 = 0xE000_0001;
+pub const INADDR_ALLRTRS_GROUP: u32 = 0xE000_0002;
+pub const INADDR_MAX_LOCAL_GROUP: u32 = 0xE000_00FF;

src/header/pwd/mod.rs

@@ -101,7 +101,7 @@ where
         // in the macro that is never read
         let mut _off = 0;
 
-        let mut parts = parts.into_iter();
+        let mut parts = parts.iter();
 
         macro_rules! copy_into {
             ($entry:expr) => {
@@ -112,11 +112,11 @@ where
 
                 for (i, c) in src.iter().enumerate() {
                     unsafe {
-                        *dst.offset(i as isize) = *c as c_char;
+                        *dst.add(i) = *c as c_char;
                     }
                 }
                 unsafe {
-                    *dst.offset(src.len() as isize) = 0;
+                    *dst.add(src.len()) = 0;
 
                     $entry = dst;
                 }
@@ -147,7 +147,7 @@ where
 }
 
 #[no_mangle]
-pub extern "C" fn getpwnam_r(
+pub unsafe extern "C" fn getpwnam_r(
     name: *const c_char,
     out: *mut passwd,
     buf: *mut c_char,
@@ -160,21 +160,21 @@ pub extern "C" fn getpwnam_r(
             // /etc/passwd should not contain any NUL bytes in the middle
             // of entries, but if this happens, it can't possibly match the
             // search query since it's NUL terminated.
-            if *c == 0 || unsafe { *name.offset(i as isize) } != *c as c_char {
+            if *c == 0 || *name.add(i) != *c as c_char {
                 return false;
             }
         }
         true
     }) {
-        OptionPasswd::Error => unsafe {
+        OptionPasswd::Error => {
             *result = ptr::null_mut();
             -1
         },
-        OptionPasswd::NotFound => unsafe {
+        OptionPasswd::NotFound => {
             *result = ptr::null_mut();
             0
         },
-        OptionPasswd::Found(_) => unsafe {
+        OptionPasswd::Found(_) => {
             *result = out;
             0
         },
@@ -182,7 +182,7 @@ pub extern "C" fn getpwnam_r(
 }
 
 #[no_mangle]
-pub extern "C" fn getpwuid_r(
+pub unsafe extern "C" fn getpwuid_r(
     uid: uid_t,
     out: *mut passwd,
     buf: *mut c_char,
@@ -196,15 +196,15 @@ pub extern "C" fn getpwuid_r(
             .and_then(|part| part.parse().ok());
         part == Some(uid)
     }) {
-        OptionPasswd::Error => unsafe {
+        OptionPasswd::Error => {
             *result = ptr::null_mut();
             -1
         },
-        OptionPasswd::NotFound => unsafe {
+        OptionPasswd::NotFound => {
             *result = ptr::null_mut();
             0
         },
-        OptionPasswd::Found(_) => unsafe {
+        OptionPasswd::Found(_) => {
             *result = out;
             0
         },
@@ -219,7 +219,7 @@ pub extern "C" fn getpwnam(name: *const c_char) -> *mut passwd {
             // /etc/passwd should not contain any NUL bytes in the middle
             // of entries, but if this happens, it can't possibly match the
             // search query since it's NUL terminated.
-            if *c == 0 || unsafe { *name.offset(i as isize) } != *c as c_char {
+            if *c == 0 || unsafe { *name.add(i) } != *c as c_char {
                 return false;
             }
         }
@@ -246,7 +246,7 @@ pub extern "C" fn getpwuid(uid: uid_t) -> *mut passwd {
         OptionPasswd::Error => ptr::null_mut(),
         OptionPasswd::NotFound => ptr::null_mut(),
         OptionPasswd::Found(buf) => unsafe {
-            if PASSWD_BUF != ptr::null_mut() {
+            if !PASSWD_BUF.is_null() {
                 platform::free(PASSWD_BUF as *mut c_void);
             }
             PASSWD_BUF = buf;

src/header/regex/mod.rs

@@ -51,18 +51,18 @@ pub const REG_BADRPT: c_int = 14;
 
 #[no_mangle]
 #[linkage = "weak"] // redefined in GIT
-pub extern "C" fn regcomp(out: *mut regex_t, pat: *const c_char, cflags: c_int) -> c_int {
+pub unsafe extern "C" fn regcomp(out: *mut regex_t, pat: *const c_char, cflags: c_int) -> c_int {
     if cflags & REG_EXTENDED == REG_EXTENDED {
         return REG_ENOSYS;
     }
 
-    let pat = unsafe { slice::from_raw_parts(pat as *const u8, strlen(pat)) };
+    let pat = slice::from_raw_parts(pat as *const u8, strlen(pat));
     let res = PosixRegexBuilder::new(pat)
         .with_default_classes()
         .compile_tokens();
 
     match res {
-        Ok(mut branches) => unsafe {
+        Ok(mut branches) => {
             let re_nsub = PosixRegex::new(Cow::Borrowed(&branches)).count_groups();
             *out = regex_t {
                 ptr: branches.as_mut_ptr() as *mut c_void,
@@ -98,7 +98,7 @@ pub unsafe extern "C" fn regfree(regex: *mut regex_t) {
 
 #[no_mangle]
 #[linkage = "weak"] // redefined in GIT
-pub extern "C" fn regexec(
+pub unsafe extern "C" fn regexec(
     regex: *const regex_t,
     input: *const c_char,
     nmatch: size_t,
@@ -109,15 +109,14 @@ pub extern "C" fn regexec(
         return REG_ENOSYS;
     }
 
-    let regex = unsafe { &(*regex) };
+    let regex = &*regex;
 
     // Allow specifying a compiler argument to the executor and vise versa
     // because why not?
     let flags = regex.cflags | eflags;
 
-    let input = unsafe { slice::from_raw_parts(input as *const u8, strlen(input)) };
-    let branches =
-        unsafe { slice::from_raw_parts(regex.ptr as *const Vec<(Token, Range)>, regex.length) };
+    let input = slice::from_raw_parts(input as *const u8, strlen(input));
+    let branches = slice::from_raw_parts(regex.ptr as *const Vec<(Token, Range)>, regex.length);
 
     let matches = PosixRegex::new(Cow::Borrowed(&branches))
         .case_insensitive(flags & REG_ICASE == REG_ICASE)
@@ -129,14 +128,12 @@ pub extern "C" fn regexec(
     if !matches.is_empty() && eflags & REG_NOSUB != REG_NOSUB && !pmatch.is_null() && nmatch > 0 {
         let first = &matches[0];
 
-        for i in 0..nmatch as usize {
+        for i in 0..nmatch {
             let (start, end) = first.get(i).and_then(|&range| range).unwrap_or((!0, !0));
-            unsafe {
-                *pmatch.offset(i as isize) = regmatch_t {
-                    rm_so: start,
-                    rm_eo: end,
-                };
-            }
+            *pmatch.add(i) = regmatch_t {
+                rm_so: start,
+                rm_eo: end,
+            };
         }
     }
 

src/header/signal/linux.rs

@@ -58,8 +58,8 @@ pub const SIGUNUSED: usize = SIGSYS;
 pub const SA_NOCLDSTOP: usize = 1;
 pub const SA_NOCLDWAIT: usize = 2;
 pub const SA_SIGINFO: usize = 4;
-pub const SA_ONSTACK: usize = 0x08000000;
-pub const SA_RESTART: usize = 0x10000000;
-pub const SA_NODEFER: usize = 0x40000000;
-pub const SA_RESETHAND: usize = 0x80000000;
-pub const SA_RESTORER: usize = 0x04000000;
+pub const SA_ONSTACK: usize = 0x0800_0000;
+pub const SA_RESTART: usize = 0x1000_0000;
+pub const SA_NODEFER: usize = 0x4000_0000;
+pub const SA_RESETHAND: usize = 0x8000_0000;
+pub const SA_RESTORER: usize = 0x0400_0000;

src/header/signal/mod.rs

@@ -201,7 +201,7 @@ pub extern "C" fn sigwait(set: *const sigset_t, sig: *mut c_int) -> c_int {
     unimplemented!();
 }
 
-pub const _signal_strings: [&'static str; 32] = [
+pub const _signal_strings: [&str; 32] = [
     "Unknown signal\0",
     "Hangup\0",
     "Interrupt\0",

src/header/stdio/getdelim.rs

@@ -7,7 +7,7 @@ use io::BufRead;
 use platform::types::*;
 
 #[no_mangle]
-pub extern "C" fn __getline(
+pub unsafe extern "C" fn __getline(
     lineptr: *mut *mut c_char,
     n: *mut size_t,
     stream: *mut FILE,
@@ -16,20 +16,20 @@ pub extern "C" fn __getline(
 }
 
 #[no_mangle]
-pub extern "C" fn __getdelim(
+pub unsafe extern "C" fn __getdelim(
     lineptr: *mut *mut c_char,
     n: *mut size_t,
     delim: c_int,
     stream: *mut FILE,
 ) -> ssize_t {
-    let lineptr = unsafe { &mut *lineptr };
-    let n = unsafe { &mut *n };
+    let lineptr = &mut *lineptr;
+    let n = &mut *n;
     let delim = delim as u8;
 
     //TODO: More efficient algorithm using lineptr and n instead of this vec
     let mut buf = Vec::new();
     let count = {
-        let mut stream = unsafe { &mut *stream }.lock();
+        let mut stream = (*stream).lock();
         match stream.read_until(delim, &mut buf) {
             Ok(ok) => ok,
             Err(err) => return -1,
@@ -37,7 +37,7 @@ pub extern "C" fn __getdelim(
     };
 
     //TODO: Check errors and improve safety
-    unsafe {
+    {
         // Allocate lineptr to size of buf and set n to size of lineptr
         *n = count + 1;
         *lineptr = stdlib::realloc(*lineptr as *mut c_void, *n) as *mut c_char;

src/header/stdio/mod.rs

@@ -3,10 +3,9 @@
 use alloc::borrow::{Borrow, BorrowMut};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use core::fmt;
+use core::{fmt, mem, ptr, slice, str};
 use core::fmt::Write as WriteFmt;
 use core::ops::{Deref, DerefMut};
-use core::{ptr, slice, str};
 use va_list::VaList as va_list;
 
 use c_str::CStr;
@@ -183,8 +182,8 @@ impl<'a> Drop for LockGuard<'a> {
 
 /// Clears EOF and ERR indicators on a stream
 #[no_mangle]
-pub extern "C" fn clearerr(stream: *mut FILE) {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn clearerr(stream: *mut FILE) {
+    let mut stream = (*stream).lock();
     stream.flags &= !(F_EOF | F_ERR);
 }
 
@@ -203,11 +202,9 @@ pub extern "C" fn cuserid(_s: *mut c_char) -> *mut c_char {
 /// descriptor will be closed, so if it is important that the file be written to, use `fflush()`
 /// prior to using this function.
 #[no_mangle]
-pub extern "C" fn fclose(stream: *mut FILE) -> c_int {
-    let stream = unsafe { &mut *stream };
-    unsafe {
-        flockfile(stream);
-    }
+pub unsafe extern "C" fn fclose(stream: *mut FILE) -> c_int {
+    let stream = &mut *stream;
+    flockfile(stream);
 
     let mut r = stream.flush().is_err();
     let close = Sys::close(*stream.file) < 0;
@@ -215,13 +212,11 @@ pub extern "C" fn fclose(stream: *mut FILE) -> c_int {
 
     if stream.flags & constants::F_PERM == 0 {
         // Not one of stdin, stdout or stderr
-        let mut stream = unsafe { Box::from_raw(stream) };
+        let mut stream = Box::from_raw(stream);
         // Reference files aren't closed on drop, so pretend to be a reference
         stream.file.reference = true;
     } else {
-        unsafe {
-            funlockfile(stream);
-        }
+        funlockfile(stream);
     }
 
     r as c_int
@@ -229,9 +224,8 @@ pub extern "C" fn fclose(stream: *mut FILE) -> c_int {
 
 /// Open a file from a file descriptor
 #[no_mangle]
-pub extern "C" fn fdopen(fildes: c_int, mode: *const c_char) -> *mut FILE {
-    use core::ptr;
-    if let Some(f) = unsafe { helpers::_fdopen(fildes, mode) } {
+pub unsafe extern "C" fn fdopen(fildes: c_int, mode: *const c_char) -> *mut FILE {
+    if let Some(f) = helpers::_fdopen(fildes, mode) {
         f
     } else {
         ptr::null_mut()
@@ -240,15 +234,15 @@ pub extern "C" fn fdopen(fildes: c_int, mode: *const c_char) -> *mut FILE {
 
 /// Check for EOF
 #[no_mangle]
-pub extern "C" fn feof(stream: *mut FILE) -> c_int {
-    let stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn feof(stream: *mut FILE) -> c_int {
+    let stream = (*stream).lock();
     stream.flags & F_EOF
 }
 
 /// Check for ERR
 #[no_mangle]
-pub extern "C" fn ferror(stream: *mut FILE) -> c_int {
-    let stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn ferror(stream: *mut FILE) -> c_int {
+    let stream = (*stream).lock();
     stream.flags & F_ERR
 }
 
@@ -256,35 +250,33 @@ pub extern "C" fn ferror(stream: *mut FILE) -> c_int {
 /// Ensure the file is unlocked before calling this function, as it will attempt to lock the file
 /// itself.
 #[no_mangle]
-pub extern "C" fn fflush(stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fflush(stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     stream.flush().is_err() as c_int
 }
 
 /// Get a single char from a stream
 #[no_mangle]
-pub extern "C" fn fgetc(stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fgetc(stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     getc_unlocked(&mut *stream)
 }
 
 /// Get the position of the stream and store it in pos
 #[no_mangle]
-pub extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t) -> c_int {
+pub unsafe extern "C" fn fgetpos(stream: *mut FILE, pos: *mut fpos_t) -> c_int {
     let off = ftello(stream);
     if off < 0 {
         return -1;
     }
-    unsafe {
-        *pos = off;
-    }
+    *pos = off;
     0
 }
 
 /// Get a string from the stream
 #[no_mangle]
-pub extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) -> *mut c_char {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) -> *mut c_char {
+    let mut stream = (*stream).lock();
     let mut out = original;
     let max = max as usize;
     let mut left = max.saturating_sub(1); // Make space for the terminating NUL-byte
@@ -292,10 +284,8 @@ pub extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) ->
 
     if left >= 1 {
         if let Some(c) = stream.unget.take() {
-            unsafe {
-                *out = c as c_char;
-                out = out.offset(1);
-            }
+            *out = c as c_char;
+            out = out.offset(1);
             left -= 1;
         }
     }
@@ -320,16 +310,14 @@ pub extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) ->
             let newline = buf[..len].iter().position(|&c| c == b'\n');
             let len = newline.map(|i| i + 1).unwrap_or(len);
 
-            unsafe {
-                ptr::copy_nonoverlapping(buf.as_ptr(), out as *mut u8, len);
-            }
+            ptr::copy_nonoverlapping(buf.as_ptr(), out as *mut u8, len);
 
             (len, newline.is_some())
         };
 
         stream.consume(read);
 
-        out = unsafe { out.offset(read as isize) };
+        out = out.add(read);
         left -= read;
 
         if exit {
@@ -352,8 +340,8 @@ pub extern "C" fn fgets(original: *mut c_char, max: c_int, stream: *mut FILE) ->
 
 /// Get the underlying file descriptor
 #[no_mangle]
-pub extern "C" fn fileno(stream: *mut FILE) -> c_int {
-    let stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fileno(stream: *mut FILE) -> c_int {
+    let stream = (*stream).lock();
     *stream.file
 }
 
@@ -367,15 +355,14 @@ pub unsafe extern "C" fn flockfile(file: *mut FILE) {
 
 /// Open the file in mode `mode`
 #[no_mangle]
-pub extern "C" fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FILE {
-    use core::ptr;
-    let initial_mode = unsafe { *mode };
+pub unsafe extern "C" fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FILE {
+    let initial_mode = *mode;
     if initial_mode != b'r' as i8 && initial_mode != b'w' as i8 && initial_mode != b'a' as i8 {
-        unsafe { platform::errno = errno::EINVAL };
+        platform::errno = errno::EINVAL;
         return ptr::null_mut();
     }
 
-    let flags = unsafe { helpers::parse_mode_flags(mode) };
+    let flags = helpers::parse_mode_flags(mode);
 
     let new_mode = if flags & fcntl::O_CREAT == fcntl::O_CREAT {
         0o666
@@ -392,7 +379,7 @@ pub extern "C" fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FI
         fcntl::sys_fcntl(fd, fcntl::F_SETFD, fcntl::FD_CLOEXEC);
     }
 
-    if let Some(f) = unsafe { helpers::_fdopen(fd, mode) } {
+    if let Some(f) = helpers::_fdopen(fd, mode) {
         f
     } else {
         Sys::close(fd);
@@ -402,28 +389,28 @@ pub extern "C" fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FI
 
 /// Insert a character into the stream
 #[no_mangle]
-pub extern "C" fn fputc(c: c_int, stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fputc(c: c_int, stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     putc_unlocked(c, &mut *stream)
 }
 
 /// Insert a string into a stream
 #[no_mangle]
-pub extern "C" fn fputs(s: *const c_char, stream: *mut FILE) -> c_int {
-    let len = unsafe { strlen(s) };
+pub unsafe extern "C" fn fputs(s: *const c_char, stream: *mut FILE) -> c_int {
+    let len = strlen(s);
     (fwrite(s as *const c_void, 1, len, stream) == len) as c_int - 1
 }
 
 /// Read `nitems` of size `size` into `ptr` from `stream`
 #[no_mangle]
-pub extern "C" fn fread(
+pub unsafe extern "C" fn fread(
     ptr: *mut c_void,
     size: size_t,
     count: size_t,
     stream: *mut FILE,
 ) -> size_t {
-    let mut stream = unsafe { &mut *stream }.lock();
-    let buf = unsafe { slice::from_raw_parts_mut(ptr as *mut u8, size as usize * count as usize) };
+    let mut stream = (*stream).lock();
+    let buf = slice::from_raw_parts_mut(ptr as *mut u8, size as usize * count as usize);
     let mut read = 0;
     while read < buf.len() {
         match stream.read(&mut buf[read..]) {
@@ -435,15 +422,13 @@ pub extern "C" fn fread(
 }
 
 #[no_mangle]
-pub extern "C" fn freopen(
+pub unsafe extern "C" fn freopen(
     filename: *const c_char,
     mode: *const c_char,
     stream: &mut FILE,
 ) -> *mut FILE {
-    let mut flags = unsafe { helpers::parse_mode_flags(mode) };
-    unsafe {
-        flockfile(stream);
-    }
+    let mut flags = helpers::parse_mode_flags(mode);
+    flockfile(stream);
 
     let _ = stream.flush();
     if filename.is_null() {
@@ -453,30 +438,24 @@ pub extern "C" fn freopen(
         }
         flags &= !(fcntl::O_CREAT | fcntl::O_EXCL | fcntl::O_CLOEXEC);
         if fcntl::sys_fcntl(*stream.file, fcntl::F_SETFL, flags) < 0 {
-            unsafe {
-                funlockfile(stream);
-            }
+            funlockfile(stream);
             fclose(stream);
             return ptr::null_mut();
         }
     } else {
         let new = fopen(filename, mode);
         if new.is_null() {
-            unsafe {
-                funlockfile(stream);
-            }
+            funlockfile(stream);
             fclose(stream);
             return ptr::null_mut();
         }
-        let new = unsafe { &mut *new }; // Should be safe, new is not null
+        let new = &mut *new; // Should be safe, new is not null
         if *new.file == *stream.file {
             new.file.fd = -1;
         } else if Sys::dup2(*new.file, *stream.file) < 0
             || fcntl::sys_fcntl(*stream.file, fcntl::F_SETFL, flags & fcntl::O_CLOEXEC) < 0
         {
-            unsafe {
-                funlockfile(stream);
-            }
+            funlockfile(stream);
             fclose(new);
             fclose(stream);
             return ptr::null_mut();
@@ -484,22 +463,20 @@ pub extern "C" fn freopen(
         stream.flags = (stream.flags & constants::F_PERM) | new.flags;
         fclose(new);
     }
-    unsafe {
-        funlockfile(stream);
-    }
+    funlockfile(stream);
     stream
 }
 
 /// Seek to an offset `offset` from `whence`
 #[no_mangle]
-pub extern "C" fn fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int {
+pub unsafe extern "C" fn fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int {
     fseeko(stream, offset as off_t, whence)
 }
 
 /// Seek to an offset `offset` from `whence`
 #[no_mangle]
-pub extern "C" fn fseeko(stream: *mut FILE, mut off: off_t, whence: c_int) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn fseeko(stream: *mut FILE, mut off: off_t, whence: c_int) -> c_int {
+    let mut stream = (*stream).lock();
 
     if whence == SEEK_CUR {
         // Since it's a buffered writer, our actual cursor isn't where the user
@@ -527,14 +504,14 @@ pub unsafe extern "C" fn fsetpos(stream: *mut FILE, pos: *const fpos_t) -> c_int
 
 /// Get the current position of the cursor in the file
 #[no_mangle]
-pub extern "C" fn ftell(stream: *mut FILE) -> c_long {
+pub unsafe extern "C" fn ftell(stream: *mut FILE) -> c_long {
     ftello(stream) as c_long
 }
 
 /// Get the current position of the cursor in the file
 #[no_mangle]
-pub extern "C" fn ftello(stream: *mut FILE) -> off_t {
-    let stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn ftello(stream: *mut FILE) -> off_t {
+    let stream = (*stream).lock();
     let pos = Sys::lseek(*stream.file, 0, SEEK_CUR);
     if pos < 0 {
         return -1;
@@ -561,14 +538,14 @@ pub unsafe extern "C" fn funlockfile(file: *mut FILE) {
 
 /// Write `nitems` of size `size` from `ptr` to `stream`
 #[no_mangle]
-pub extern "C" fn fwrite(
+pub unsafe extern "C" fn fwrite(
     ptr: *const c_void,
     size: size_t,
     count: size_t,
     stream: *mut FILE,
 ) -> size_t {
-    let mut stream = unsafe { &mut *stream }.lock();
-    let buf = unsafe { slice::from_raw_parts_mut(ptr as *mut u8, size as usize * count as usize) };
+    let mut stream = (*stream).lock();
+    let buf = slice::from_raw_parts_mut(ptr as *mut u8, size as usize * count as usize);
     let mut written = 0;
     while written < buf.len() {
         match stream.write(&mut buf[written..]) {
@@ -581,23 +558,23 @@ pub extern "C" fn fwrite(
 
 /// Get a single char from a stream
 #[no_mangle]
-pub extern "C" fn getc(stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn getc(stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     getc_unlocked(&mut *stream)
 }
 
 /// Get a single char from `stdin`
 #[no_mangle]
-pub extern "C" fn getchar() -> c_int {
-    fgetc(unsafe { &mut *stdin })
+pub unsafe extern "C" fn getchar() -> c_int {
+    fgetc(&mut *stdin)
 }
 
 /// Get a char from a stream without locking the stream
 #[no_mangle]
-pub extern "C" fn getc_unlocked(stream: *mut FILE) -> c_int {
+pub unsafe extern "C" fn getc_unlocked(stream: *mut FILE) -> c_int {
     let mut buf = [0];
 
-    match unsafe { &mut *stream }.read(&mut buf) {
+    match (*stream).read(&mut buf) {
         Ok(0) | Err(_) => EOF,
         Ok(_) => buf[0] as c_int,
     }
@@ -605,20 +582,19 @@ pub extern "C" fn getc_unlocked(stream: *mut FILE) -> c_int {
 
 /// Get a char from `stdin` without locking `stdin`
 #[no_mangle]
-pub extern "C" fn getchar_unlocked() -> c_int {
-    getc_unlocked(unsafe { &mut *stdin })
+pub unsafe extern "C" fn getchar_unlocked() -> c_int {
+    getc_unlocked(&mut *stdin)
 }
 
 /// Get a string from `stdin`
 #[no_mangle]
-pub extern "C" fn gets(s: *mut c_char) -> *mut c_char {
-    fgets(s, c_int::max_value(), unsafe { &mut *stdin })
+pub unsafe extern "C" fn gets(s: *mut c_char) -> *mut c_char {
+    fgets(s, c_int::max_value(), &mut *stdin)
 }
 
 /// Get an integer from `stream`
 #[no_mangle]
-pub extern "C" fn getw(stream: *mut FILE) -> c_int {
-    use core::mem;
+pub unsafe extern "C" fn getw(stream: *mut FILE) -> c_int {
     let mut ret: c_int = 0;
     if fread(
         &mut ret as *mut _ as *mut c_void,
@@ -634,14 +610,14 @@ pub extern "C" fn getw(stream: *mut FILE) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn pclose(stream: *mut FILE) -> c_int {
+pub unsafe extern "C" fn pclose(stream: *mut FILE) -> c_int {
     let pid = {
-        let mut stream = unsafe { &mut *stream }.lock();
+        let mut stream = (*stream).lock();
 
         if let Some(pid) = stream.pid.take() {
             pid
         } else {
-            unsafe { errno = errno::ECHILD };
+            errno = errno::ECHILD;
             return -1;
         }
     };
@@ -761,21 +737,21 @@ pub unsafe extern "C" fn popen(command: *const c_char, mode: *const c_char) -> *
 
 /// Put a character `c` into `stream`
 #[no_mangle]
-pub extern "C" fn putc(c: c_int, stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn putc(c: c_int, stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     putc_unlocked(c, &mut *stream)
 }
 
 /// Put a character `c` into `stdout`
 #[no_mangle]
-pub extern "C" fn putchar(c: c_int) -> c_int {
-    fputc(c, unsafe { &mut *stdout })
+pub unsafe extern "C" fn putchar(c: c_int) -> c_int {
+    fputc(c, &mut *stdout)
 }
 
 /// Put a character `c` into `stream` without locking `stream`
 #[no_mangle]
-pub extern "C" fn putc_unlocked(c: c_int, stream: *mut FILE) -> c_int {
-    match unsafe { &mut *stream }.write(&[c as u8]) {
+pub unsafe extern "C" fn putc_unlocked(c: c_int, stream: *mut FILE) -> c_int {
+    match (*stream).write(&[c as u8]) {
         Ok(0) | Err(_) => EOF,
         Ok(_) => c,
     }
@@ -783,14 +759,14 @@ pub extern "C" fn putc_unlocked(c: c_int, stream: *mut FILE) -> c_int {
 
 /// Put a character `c` into `stdout` without locking `stdout`
 #[no_mangle]
-pub extern "C" fn putchar_unlocked(c: c_int) -> c_int {
-    putc_unlocked(c, unsafe { stdout })
+pub unsafe extern "C" fn putchar_unlocked(c: c_int) -> c_int {
+    putc_unlocked(c, stdout)
 }
 
 /// Put a string `s` into `stdout`
 #[no_mangle]
-pub extern "C" fn puts(s: *const c_char) -> c_int {
-    let ret = (fputs(s, unsafe { stdout }) > 0) || (putchar_unlocked(b'\n' as c_int) > 0);
+pub unsafe extern "C" fn puts(s: *const c_char) -> c_int {
+    let ret = (fputs(s, stdout) > 0) || (putchar_unlocked(b'\n' as c_int) > 0);
     if ret {
         0
     } else {
@@ -800,15 +776,14 @@ pub extern "C" fn puts(s: *const c_char) -> c_int {
 
 /// Put an integer `w` into `stream`
 #[no_mangle]
-pub extern "C" fn putw(w: c_int, stream: *mut FILE) -> c_int {
-    use core::mem;
+pub unsafe extern "C" fn putw(w: c_int, stream: *mut FILE) -> c_int {
     fwrite(&w as *const c_int as _, mem::size_of_val(&w), 1, stream) as i32 - 1
 }
 
 /// Delete file or directory `path`
 #[no_mangle]
-pub extern "C" fn remove(path: *const c_char) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn remove(path: *const c_char) -> c_int {
+    let path = CStr::from_ptr(path);
     let r = Sys::unlink(path);
     if r == -errno::EISDIR {
         Sys::rmdir(path)
@@ -818,21 +793,21 @@ pub extern "C" fn remove(path: *const c_char) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn rename(oldpath: *const c_char, newpath: *const c_char) -> c_int {
-    let oldpath = unsafe { CStr::from_ptr(oldpath) };
-    let newpath = unsafe { CStr::from_ptr(newpath) };
+pub unsafe extern "C" fn rename(oldpath: *const c_char, newpath: *const c_char) -> c_int {
+    let oldpath = CStr::from_ptr(oldpath);
+    let newpath = CStr::from_ptr(newpath);
     Sys::rename(oldpath, newpath)
 }
 
 /// Rewind `stream` back to the beginning of it
 #[no_mangle]
-pub extern "C" fn rewind(stream: *mut FILE) {
+pub unsafe extern "C" fn rewind(stream: *mut FILE) {
     fseeko(stream, 0, SEEK_SET);
 }
 
 /// Reset `stream` to use buffer `buf`. Buffer must be `BUFSIZ` in length
 #[no_mangle]
-pub extern "C" fn setbuf(stream: *mut FILE, buf: *mut c_char) {
+pub unsafe extern "C" fn setbuf(stream: *mut FILE, buf: *mut c_char) {
     setvbuf(
         stream,
         buf,
@@ -844,13 +819,13 @@ pub extern "C" fn setbuf(stream: *mut FILE, buf: *mut c_char) {
 /// Reset `stream` to use buffer `buf` of size `size`
 /// If this isn't the meaning of unsafe, idk what is
 #[no_mangle]
-pub extern "C" fn setvbuf(
+pub unsafe extern "C" fn setvbuf(
     stream: *mut FILE,
     buf: *mut c_char,
     mode: c_int,
     mut size: size_t,
 ) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+    let mut stream = (*stream).lock();
     // Set a buffer of size `size` if no buffer is given
     stream.read_buf = if buf.is_null() || size == 0 {
         if size == 0 {
@@ -874,8 +849,8 @@ pub extern "C" fn tempnam(_dir: *const c_char, _pfx: *const c_char) -> *mut c_ch
 }
 
 #[no_mangle]
-pub extern "C" fn tmpfile() -> *mut FILE {
-    let mut file_name = *b"/tmp/tmpfileXXXXXX";
+pub unsafe extern "C" fn tmpfile() -> *mut FILE {
+    let mut file_name = *b"/tmp/tmpfileXXXXXX\0";
     let file_name = file_name.as_mut_ptr() as *mut c_char;
     let fd = stdlib::mkstemp(file_name);
 
@@ -883,9 +858,9 @@ pub extern "C" fn tmpfile() -> *mut FILE {
         return ptr::null_mut();
     }
 
-    let fp = fdopen(fd, b"w+".as_ptr() as *const i8);
+    let fp = fdopen(fd, c_str!("w+").as_ptr());
     {
-        let file_name = unsafe { CStr::from_ptr(file_name) };
+        let file_name = CStr::from_ptr(file_name);
         Sys::unlink(file_name);
     }
 
@@ -903,13 +878,11 @@ pub extern "C" fn tmpnam(_s: *mut c_char) -> *mut c_char {
 
 /// Push character `c` back onto `stream` so it'll be read next
 #[no_mangle]
-pub extern "C" fn ungetc(c: c_int, stream: *mut FILE) -> c_int {
-    let mut stream = unsafe { &mut *stream }.lock();
+pub unsafe extern "C" fn ungetc(c: c_int, stream: *mut FILE) -> c_int {
+    let mut stream = (*stream).lock();
     if stream.unget.is_some() {
-        unsafe {
-            platform::errno = errno::EIO;
-            return EOF;
-        }
+        platform::errno = errno::EIO;
+        return EOF;
     }
     stream.unget = Some(c as u8);
     c

src/header/stdio/scanf.rs

@@ -60,10 +60,8 @@ unsafe fn inner_scanf<R: Read>(
             maybe_read!(inner);
         };
         (inner $($placeholder:expr)*) => {
-            if !skip_read {
-                if !read!() {
-                    return Ok(matched);
-                }
+            if !skip_read && !read!() {
+                return Ok(matched);
             }
             $(else {
                 // Hacky way of having this optional
@@ -205,10 +203,8 @@ unsafe fn inner_scanf<R: Read>(
                             {
                                 radix = 16;
                                 width = width.map(|w| w - 1);
-                                if width.map(|w| w > 0).unwrap_or(true) {
-                                    if !read!() {
-                                        break;
-                                    }
+                                if width.map(|w| w > 0).unwrap_or(true) && !read!() {
+                                    break;
                                 }
                             }
                             continue;
@@ -219,10 +215,8 @@ unsafe fn inner_scanf<R: Read>(
                         }
                         n.push(byte as char);
                         width = width.map(|w| w - 1);
-                        if width.map(|w| w > 0).unwrap_or(true) {
-                            if !read!() {
-                                break;
-                            }
+                        if width.map(|w| w > 0).unwrap_or(true) && !read!() {
+                            break;
                         }
                     }
 
@@ -340,10 +334,8 @@ unsafe fn inner_scanf<R: Read>(
                             *ptr = ptr.offset(1);
                         }
                         width = width.map(|w| w - 1);
-                        if width.map(|w| w > 0).unwrap_or(true) {
-                            if !read!() {
-                                break;
-                            }
+                        if width.map(|w| w > 0).unwrap_or(true) && !read!() {
+                            break;
                         }
                     }
 
@@ -357,13 +349,11 @@ unsafe fn inner_scanf<R: Read>(
 
                     for i in 0..width.unwrap_or(1) {
                         if let Some(ptr) = ptr {
-                            *ptr.offset(i as isize) = byte as c_char;
+                            *ptr.add(i) = byte as c_char;
                         }
                         width = width.map(|w| w - 1);
-                        if width.map(|w| w > 0).unwrap_or(true) {
-                            if !read!() {
-                                break;
-                            }
+                        if width.map(|w| w > 0).unwrap_or(true) && !read!() {
+                            break;
                         }
                     }
 
@@ -414,10 +404,8 @@ unsafe fn inner_scanf<R: Read>(
                             *ptr = ptr.offset(1);
                         }
                         width = width.map(|w| w - 1);
-                        if width.map(|w| w > 0).unwrap_or(true) {
-                            if !read!() {
-                                break;
-                            }
+                        if width.map(|w| w > 0).unwrap_or(true) && !read!() {
+                            break;
                         }
                     }
 

src/header/stdlib/mod.rs

@@ -23,7 +23,7 @@ mod sort;
 
 pub const EXIT_FAILURE: c_int = 1;
 pub const EXIT_SUCCESS: c_int = 0;
-pub const RAND_MAX: c_int = 2147483647;
+pub const RAND_MAX: c_int = 2_147_483_647;
 
 //Maximum number of bytes in a multibyte character for the current locale
 pub const MB_CUR_MAX: c_int = 4;
@@ -57,7 +57,7 @@ pub unsafe extern "C" fn a64l(s: *const c_char) -> c_long {
         bits <<= 6 * x;
         l |= bits;
     }
-    return l;
+    l
 }
 
 #[no_mangle]
@@ -145,7 +145,7 @@ pub extern "C" fn atol(s: *const c_char) -> c_long {
 }
 
 unsafe extern "C" fn void_cmp(a: *const c_void, b: *const c_void) -> c_int {
-    return *(a as *const i32) - *(b as *const i32) as c_int;
+    *(a as *const i32) - *(b as *const i32) as c_int
 }
 
 #[no_mangle]
@@ -267,7 +267,7 @@ pub extern "C" fn gcvt(value: c_double, ndigit: c_int, buf: *mut c_char) -> *mut
 unsafe fn find_env(search: *const c_char) -> Option<(usize, *mut c_char)> {
     for (i, item) in platform::inner_environ.iter().enumerate() {
         let mut item = *item;
-        if item == ptr::null_mut() {
+        if item.is_null() {
             assert_eq!(
                 i,
                 platform::inner_environ.len() - 1,
@@ -449,21 +449,18 @@ where
 }
 
 #[no_mangle]
-pub extern "C" fn mktemp(name: *mut c_char) -> *mut c_char {
-    if inner_mktemp(name, 0, || unsafe {
+pub unsafe extern "C" fn mktemp(name: *mut c_char) -> *mut c_char {
+    if inner_mktemp(name, 0, || {
         let name = CStr::from_ptr(name);
-        let ret = if Sys::access(name, 0) != 0 && platform::errno == ENOENT {
+        if Sys::access(name, 0) != 0 && platform::errno == ENOENT {
             Some(())
         } else {
             None
-        };
-        ret
+        }
     })
     .is_none()
     {
-        unsafe {
-            *name = 0;
-        }
+        *name = 0;
     }
     name
 }
@@ -481,7 +478,7 @@ pub extern "C" fn mkostemps(name: *mut c_char, suffix_len: c_int, mut flags: c_i
 
     inner_mktemp(name, suffix_len, || {
         let name = unsafe { CStr::from_ptr(name) };
-        let fd = Sys::open(name, flags, 0600);
+        let fd = Sys::open(name, flags, 0o600);
 
         if fd >= 0 {
             Some(fd)
@@ -720,12 +717,12 @@ pub fn is_positive(ch: c_char) -> Option<(bool, isize)> {
     }
 }
 
-pub fn detect_base(s: *const c_char) -> Option<(c_int, isize)> {
-    let first = unsafe { *s } as u8;
+pub unsafe fn detect_base(s: *const c_char) -> Option<(c_int, isize)> {
+    let first = *s as u8;
     match first {
         0 => None,
         b'0' => {
-            let second = unsafe { *s.offset(1) } as u8;
+            let second = *s.offset(1) as u8;
             if second == b'X' || second == b'x' {
                 Some((16, 2))
             } else if second >= b'0' && second <= b'7' {
@@ -762,7 +759,7 @@ pub unsafe fn convert_hex(s: *const c_char) -> Option<(c_ulong, isize, bool)> {
     }
 }
 
-pub fn convert_integer(s: *const c_char, base: c_int) -> Option<(c_ulong, isize, bool)> {
+pub unsafe fn convert_integer(s: *const c_char, base: c_int) -> Option<(c_ulong, isize, bool)> {
     // -1 means the character is invalid
     #[cfg_attr(rustfmt, rustfmt_skip)]
     const LOOKUP_TABLE: [c_long; 256] = [
@@ -792,7 +789,7 @@ pub fn convert_integer(s: *const c_char, base: c_int) -> Option<(c_ulong, isize,
         // `-1 as usize` is usize::MAX
         // `-1 as u8 as usize` is u8::MAX
         // It extends by the sign bit unless we cast it to unsigned first.
-        let val = unsafe { LOOKUP_TABLE[*s.offset(idx) as u8 as usize] };
+        let val = LOOKUP_TABLE[*s.offset(idx) as u8 as usize];
         if val == -1 || val as c_int >= base {
             break;
         } else {
@@ -802,9 +799,7 @@ pub fn convert_integer(s: *const c_char, base: c_int) -> Option<(c_ulong, isize,
             {
                 num = res;
             } else {
-                unsafe {
-                    platform::errno = ERANGE;
-                }
+                platform::errno = ERANGE;
                 num = c_ulong::max_value();
                 overflowed = true;
             }

src/header/stdlib/sort.rs

@@ -137,7 +137,7 @@ fn heap_sift_down(
             swap_idx = child;
             swap_ptr = first_child_ptr;
         }
-        if child + 1 <= end
+        if child < end
             && comp(swap_ptr as *const c_void, second_child_ptr as *const c_void) < 0
         {
             swap_idx = child + 1;

src/header/string/mod.rs

@@ -26,7 +26,7 @@ pub unsafe extern "C" fn memccpy(
     if memcpy(dest, src, dist).is_null() {
         return ptr::null_mut();
     }
-    (dest as *mut u8).offset(dist as isize + 1) as *mut c_void
+    (dest as *mut u8).add(dist + 1) as *mut c_void
 }
 
 #[no_mangle]
@@ -79,8 +79,8 @@ pub unsafe extern "C" fn memcmp(s1: *const c_void, s2: *const c_void, n: size_t)
     for _ in 0..div {
         if *a != *b {
             for i in 0..mem::size_of::<usize>() {
-                let c = *(a as *const u8).offset(i as isize);
-                let d = *(b as *const u8).offset(i as isize);
+                let c = *(a as *const u8).add(i);
+                let d = *(b as *const u8).add(i);
                 if c != d {
                     return c as c_int - d as c_int;
                 }
@@ -107,11 +107,11 @@ pub unsafe extern "C" fn memcmp(s1: *const c_void, s2: *const c_void, n: size_t)
 pub unsafe extern "C" fn memcpy(s1: *mut c_void, s2: *const c_void, n: size_t) -> *mut c_void {
     let mut i = 0;
     while i + 7 < n {
-        *(s1.offset(i as isize) as *mut u64) = *(s2.offset(i as isize) as *const u64);
+        *(s1.add(i) as *mut u64) = *(s2.add(i) as *const u64);
         i += 8;
     }
     while i < n {
-        *(s1 as *mut u8).offset(i as isize) = *(s2 as *const u8).offset(i as isize);
+        *(s1 as *mut u8).add(i) = *(s2 as *const u8).add(i);
         i += 1;
     }
     s1
@@ -124,13 +124,13 @@ pub unsafe extern "C" fn memmove(s1: *mut c_void, s2: *const c_void, n: size_t)
         let mut i = n;
         while i != 0 {
             i -= 1;
-            *(s1 as *mut u8).offset(i as isize) = *(s2 as *const u8).offset(i as isize);
+            *(s1 as *mut u8).add(i) = *(s2 as *const u8).add(i);
         }
     } else {
         // copy from beginning
         let mut i = 0;
         while i < n {
-            *(s1 as *mut u8).offset(i as isize) = *(s2 as *const u8).offset(i as isize);
+            *(s1 as *mut u8).add(i) = *(s2 as *const u8).add(i);
             i += 1;
         }
     }
@@ -141,7 +141,7 @@ pub unsafe extern "C" fn memmove(s1: *mut c_void, s2: *const c_void, n: size_t)
 pub unsafe extern "C" fn memset(s: *mut c_void, c: c_int, n: size_t) -> *mut c_void {
     let mut i = 0;
     while i < n {
-        *(s as *mut u8).offset(i as isize) = c as u8;
+        *(s as *mut u8).add(i) = c as u8;
         i += 1;
     }
     s
@@ -235,10 +235,12 @@ pub unsafe extern "C" fn strndup(s1: *const c_char, size: size_t) -> *mut c_char
         platform::errno = ENOMEM as c_int;
     } else {
         //memcpy(buffer, s1, len)
-        for i in 0..len as isize {
-            *buffer.offset(i) = *s1.offset(i);
+        let mut i = 0;
+        while i < len {
+            *buffer.add(i) = *s1.add(i);
+            i += 1;
         }
-        *buffer.offset(len as isize) = 0;
+        *buffer.add(len) = 0;
     }
 
     buffer
@@ -270,7 +272,7 @@ pub unsafe extern "C" fn strlen(s: *const c_char) -> size_t {
 pub unsafe extern "C" fn strnlen(s: *const c_char, size: size_t) -> size_t {
     let mut i = 0;
     while i < size {
-        if *s.offset(i as isize) == 0 {
+        if *s.add(i) == 0 {
             break;
         }
         i += 1;
@@ -288,15 +290,15 @@ pub unsafe extern "C" fn strncat(s1: *mut c_char, s2: *const c_char, n: size_t)
     let len = strlen(s1 as *const c_char);
     let mut i = 0;
     while i < n {
-        let b = *s2.offset(i as isize);
+        let b = *s2.add(i);
         if b == 0 {
             break;
         }
 
-        *s1.offset((len + i) as isize) = b;
+        *s1.add(len + i) = b;
         i += 1;
     }
-    *s1.offset((len + i) as isize) = 0;
+    *s1.add(len + i) = 0;
 
     s1
 }
@@ -334,7 +336,7 @@ pub unsafe extern "C" fn strncpy(dst: *mut c_char, src: *const c_char, n: size_t
 
 #[no_mangle]
 pub unsafe extern "C" fn strpbrk(s1: *const c_char, s2: *const c_char) -> *mut c_char {
-    let p = s1.offset(strcspn(s1, s2) as isize);
+    let p = s1.add(strcspn(s1, s2));
     if *p != 0 {
         p as *mut c_char
     } else {
@@ -400,49 +402,45 @@ pub unsafe extern "C" fn strcasestr(haystack: *const c_char, needle: *const c_ch
 }
 
 #[no_mangle]
-pub extern "C" fn strtok(s1: *mut c_char, delimiter: *const c_char) -> *mut c_char {
+pub unsafe extern "C" fn strtok(s1: *mut c_char, delimiter: *const c_char) -> *mut c_char {
     static mut HAYSTACK: *mut c_char = ptr::null_mut();
-    unsafe {
-        return strtok_r(s1, delimiter, &mut HAYSTACK);
-    }
+    strtok_r(s1, delimiter, &mut HAYSTACK)
 }
 
 #[no_mangle]
-pub extern "C" fn strtok_r(
+pub unsafe extern "C" fn strtok_r(
     s: *mut c_char,
     delimiter: *const c_char,
     lasts: *mut *mut c_char,
 ) -> *mut c_char {
     // Loosely based on GLIBC implementation
-    unsafe {
-        let mut haystack = s;
-        if haystack.is_null() {
-            if (*lasts).is_null() {
-                return ptr::null_mut();
-            }
-            haystack = *lasts;
-        }
-
-        // Skip past any extra delimiter left over from previous call
-        haystack = haystack.add(strspn(haystack, delimiter));
-        if *haystack == 0 {
-            *lasts = ptr::null_mut();
+    let mut haystack = s;
+    if haystack.is_null() {
+        if (*lasts).is_null() {
             return ptr::null_mut();
         }
+        haystack = *lasts;
+    }
 
-        // Build token by injecting null byte into delimiter
-        let token = haystack;
-        haystack = strpbrk(token, delimiter);
-        if !haystack.is_null() {
-            haystack.write(0);
-            haystack = haystack.add(1);
-            *lasts = haystack;
-        } else {
-            *lasts = ptr::null_mut();
-        }
+    // Skip past any extra delimiter left over from previous call
+    haystack = haystack.add(strspn(haystack, delimiter));
+    if *haystack == 0 {
+        *lasts = ptr::null_mut();
+        return ptr::null_mut();
+    }
 
-        return token;
+    // Build token by injecting null byte into delimiter
+    let token = haystack;
+    haystack = strpbrk(token, delimiter);
+    if !haystack.is_null() {
+        haystack.write(0);
+        haystack = haystack.add(1);
+        *lasts = haystack;
+    } else {
+        *lasts = ptr::null_mut();
     }
+
+    token
 }
 
 #[no_mangle]

src/header/sys_ioctl/mod.rs

@@ -75,18 +75,18 @@ pub mod inner {
     pub const TIOCGSID: c_ulong = 0x5429;
     pub const TIOCGRS485: c_ulong = 0x542E;
     pub const TIOCSRS485: c_ulong = 0x542F;
-    pub const TIOCGPTN: c_ulong = 0x80045430;
-    pub const TIOCSPTLCK: c_ulong = 0x40045431;
-    pub const TIOCGDEV: c_ulong = 0x80045432;
+    pub const TIOCGPTN: c_ulong = 0x8004_5430;
+    pub const TIOCSPTLCK: c_ulong = 0x4004_5431;
+    pub const TIOCGDEV: c_ulong = 0x8004_5432;
     pub const TCGETX: c_ulong = 0x5432;
     pub const TCSETX: c_ulong = 0x5433;
     pub const TCSETXF: c_ulong = 0x5434;
     pub const TCSETXW: c_ulong = 0x5435;
-    pub const TIOCSIG: c_ulong = 0x40045436;
+    pub const TIOCSIG: c_ulong = 0x4004_5436;
     pub const TIOCVHANGUP: c_ulong = 0x5437;
-    pub const TIOCGPKT: c_ulong = 0x80045438;
-    pub const TIOCGPTLCK: c_ulong = 0x80045439;
-    pub const TIOCGEXCL: c_ulong = 0x80045440;
+    pub const TIOCGPKT: c_ulong = 0x8004_5438;
+    pub const TIOCGPTLCK: c_ulong = 0x8004_5439;
+    pub const TIOCGEXCL: c_ulong = 0x8004_5440;
     pub const TIOCGPTPEER: c_ulong = 0x5441;
 
     pub const FIONCLEX: c_ulong = 0x5450;

src/header/sys_socket/constants.rs

@@ -2,8 +2,8 @@ use platform::types::*;
 
 pub const SOCK_STREAM: c_int = 1;
 pub const SOCK_DGRAM: c_int = 2;
-pub const SOCK_NONBLOCK: c_int = 0o4000;
-pub const SOCK_CLOEXEC: c_int = 0o2000000;
+pub const SOCK_NONBLOCK: c_int = 0o4_000;
+pub const SOCK_CLOEXEC: c_int = 0o2_000_000;
 
 // Other constants
 pub const SOCK_SEQPACKET: c_int = 5;

src/header/sys_stat/mod.rs

@@ -6,33 +6,33 @@ use header::time::timespec;
 use platform::types::*;
 use platform::{Pal, Sys};
 
-pub const S_IFMT: c_int = 0o0170000;
-
-pub const S_IFDIR: c_int = 0o040000;
-pub const S_IFCHR: c_int = 0o020000;
-pub const S_IFBLK: c_int = 0o060000;
-pub const S_IFREG: c_int = 0o100000;
-pub const S_IFIFO: c_int = 0o010000;
-pub const S_IFLNK: c_int = 0o120000;
-pub const S_IFSOCK: c_int = 0o140000;
-
-pub const S_IRWXU: c_int = 0o0700;
-pub const S_IRUSR: c_int = 0o0400;
-pub const S_IWUSR: c_int = 0o0200;
-pub const S_IXUSR: c_int = 0o0100;
-
-pub const S_IRWXG: c_int = 0o0070;
-pub const S_IRGRP: c_int = 0o0040;
-pub const S_IWGRP: c_int = 0o0020;
-pub const S_IXGRP: c_int = 0o0010;
-
-pub const S_IRWXO: c_int = 0o0007;
-pub const S_IROTH: c_int = 0o0004;
-pub const S_IWOTH: c_int = 0o0002;
-pub const S_IXOTH: c_int = 0o0001;
-pub const S_ISUID: c_int = 0o4000;
-pub const S_ISGID: c_int = 0o2000;
-pub const S_ISVTX: c_int = 0o1000;
+pub const S_IFMT: c_int = 0o0_170_000;
+
+pub const S_IFDIR: c_int = 0o040_000;
+pub const S_IFCHR: c_int = 0o020_000;
+pub const S_IFBLK: c_int = 0o060_000;
+pub const S_IFREG: c_int = 0o100_000;
+pub const S_IFIFO: c_int = 0o010_000;
+pub const S_IFLNK: c_int = 0o120_000;
+pub const S_IFSOCK: c_int = 0o140_000;
+
+pub const S_IRWXU: c_int = 0o0_700;
+pub const S_IRUSR: c_int = 0o0_400;
+pub const S_IWUSR: c_int = 0o0_200;
+pub const S_IXUSR: c_int = 0o0_100;
+
+pub const S_IRWXG: c_int = 0o0_070;
+pub const S_IRGRP: c_int = 0o0_040;
+pub const S_IWGRP: c_int = 0o0_020;
+pub const S_IXGRP: c_int = 0o0_010;
+
+pub const S_IRWXO: c_int = 0o0_007;
+pub const S_IROTH: c_int = 0o0_004;
+pub const S_IWOTH: c_int = 0o0_002;
+pub const S_IXOTH: c_int = 0o0_001;
+pub const S_ISUID: c_int = 0o4_000;
+pub const S_ISGID: c_int = 0o2_000;
+pub const S_ISVTX: c_int = 0o1_000;
 
 #[repr(C)]
 #[derive(Default)]
@@ -59,8 +59,8 @@ pub struct stat {
 }
 
 #[no_mangle]
-pub extern "C" fn chmod(path: *const c_char, mode: mode_t) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn chmod(path: *const c_char, mode: mode_t) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::chmod(path, mode)
 }
 
@@ -85,8 +85,8 @@ pub extern "C" fn futimens(fd: c_int, times: *const timespec) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn lstat(path: *const c_char, buf: *mut stat) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn lstat(path: *const c_char, buf: *mut stat) -> c_int {
+    let path = CStr::from_ptr(path);
     let fd = Sys::open(path, O_PATH | O_NOFOLLOW, 0);
     if fd < 0 {
         return -1;
@@ -100,14 +100,14 @@ pub extern "C" fn lstat(path: *const c_char, buf: *mut stat) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn mkdir(path: *const c_char, mode: mode_t) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn mkdir(path: *const c_char, mode: mode_t) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::mkdir(path, mode)
 }
 
 #[no_mangle]
-pub extern "C" fn mkfifo(path: *const c_char, mode: mode_t) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn mkfifo(path: *const c_char, mode: mode_t) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::mkfifo(path, mode)
 }
 
@@ -117,8 +117,8 @@ pub extern "C" fn mknod(path: *const c_char, mode: mode_t, dev: dev_t) -> c_int
 }
 
 #[no_mangle]
-pub extern "C" fn stat(file: *const c_char, buf: *mut stat) -> c_int {
-    let file = unsafe { CStr::from_ptr(file) };
+pub unsafe extern "C" fn stat(file: *const c_char, buf: *mut stat) -> c_int {
+    let file = CStr::from_ptr(file);
     let fd = Sys::open(file, O_PATH, 0);
     if fd < 0 {
         return -1;

src/header/sys_wait/mod.rs

@@ -11,12 +11,12 @@ pub const WUNTRACED: c_int = 2;
 pub const WSTOPPED: c_int = 2;
 pub const WEXITED: c_int = 4;
 pub const WCONTINUED: c_int = 8;
-pub const WNOWAIT: c_int = 0x1000000;
+pub const WNOWAIT: c_int = 0x0100_0000;
 
-pub const __WNOTHREAD: c_int = 0x20000000;
-pub const __WALL: c_int = 0x40000000;
+pub const __WNOTHREAD: c_int = 0x2000_0000;
+pub const __WALL: c_int = 0x4000_0000;
 #[allow(overflowing_literals)]
-pub const __WCLONE: c_int = 0x80000000;
+pub const __WCLONE: c_int = 0x8000_0000;
 
 #[no_mangle]
 pub unsafe extern "C" fn wait(stat_loc: *mut c_int) -> pid_t {

src/header/termios/mod.rs

@@ -34,38 +34,38 @@ pub extern "C" fn tcsetattr(fd: c_int, act: c_int, value: *mut termios) -> c_int
 }
 
 #[no_mangle]
-pub extern "C" fn cfgetispeed(termios_p: *const termios) -> speed_t {
-    unsafe { (*termios_p).__c_ispeed }
+pub unsafe extern "C" fn cfgetispeed(termios_p: *const termios) -> speed_t {
+    (*termios_p).__c_ispeed
 }
 
 #[no_mangle]
-pub extern "C" fn cfgetospeed(termios_p: *const termios) -> speed_t {
-    unsafe { (*termios_p).__c_ospeed }
+pub unsafe extern "C" fn cfgetospeed(termios_p: *const termios) -> speed_t {
+    (*termios_p).__c_ospeed
 }
 
 #[no_mangle]
-pub extern "C" fn cfsetispeed(termios_p: *mut termios, speed: speed_t) -> c_int {
+pub unsafe extern "C" fn cfsetispeed(termios_p: *mut termios, speed: speed_t) -> c_int {
     match speed as usize {
         B0..=B38400 | B57600..=B4000000 => {
-            unsafe { (*termios_p).__c_ispeed = speed };
+            (*termios_p).__c_ispeed = speed;
             0
         }
         _ => {
-            unsafe { platform::errno = errno::EINVAL };
+            platform::errno = errno::EINVAL;
             -1
         }
     }
 }
 
 #[no_mangle]
-pub extern "C" fn cfsetospeed(termios_p: *mut termios, speed: speed_t) -> c_int {
+pub unsafe extern "C" fn cfsetospeed(termios_p: *mut termios, speed: speed_t) -> c_int {
     match speed as usize {
         B0..=B38400 | B57600..=B4000000 => {
-            unsafe { (*termios_p).__c_ospeed = speed };
+            (*termios_p).__c_ospeed = speed;
             0
         }
         _ => {
-            unsafe { platform::errno = errno::EINVAL };
+            platform::errno = errno::EINVAL;
             -1
         }
     }
@@ -89,89 +89,89 @@ pub const VWERASE: usize = 14;
 pub const VLNEXT: usize = 15;
 pub const VEOL2: usize = 16;
 
-pub const IGNBRK: usize = 0o000001;
-pub const BRKINT: usize = 0o000002;
-pub const IGNPAR: usize = 0o000004;
-pub const PARMRK: usize = 0o000010;
-pub const INPCK: usize = 0o000020;
-pub const ISTRIP: usize = 0o000040;
-pub const INLCR: usize = 0o000100;
-pub const IGNCR: usize = 0o000200;
-pub const ICRNL: usize = 0o000400;
-pub const IUCLC: usize = 0o001000;
-pub const IXON: usize = 0o002000;
-pub const IXANY: usize = 0o004000;
-pub const IXOFF: usize = 0o010000;
-pub const IMAXBEL: usize = 0o020000;
-pub const IUTF8: usize = 0o040000;
-
-pub const OPOST: usize = 0o000001;
-pub const OLCUC: usize = 0o000002;
-pub const ONLCR: usize = 0o000004;
-pub const OCRNL: usize = 0o000010;
-pub const ONOCR: usize = 0o000020;
-pub const ONLRET: usize = 0o000040;
-pub const OFILL: usize = 0o000100;
-pub const OFDEL: usize = 0o000200;
-
-pub const VTDLY: usize = 0o040000;
-pub const VT0: usize = 0o000000;
-pub const VT1: usize = 0o040000;
-
-pub const B0: usize = 0o000000;
-pub const B50: usize = 0o000001;
-pub const B75: usize = 0o000002;
-pub const B110: usize = 0o000003;
-pub const B134: usize = 0o000004;
-pub const B150: usize = 0o000005;
-pub const B200: usize = 0o000006;
-pub const B300: usize = 0o000007;
-pub const B600: usize = 0o000010;
-pub const B1200: usize = 0o000011;
-pub const B1800: usize = 0o000012;
-pub const B2400: usize = 0o000013;
-pub const B4800: usize = 0o000014;
-pub const B9600: usize = 0o000015;
-pub const B19200: usize = 0o000016;
-pub const B38400: usize = 0o000017;
-
-pub const B57600: usize = 0o010001;
-pub const B115200: usize = 0o010002;
-pub const B230400: usize = 0o010003;
-pub const B460800: usize = 0o010004;
-pub const B500000: usize = 0o010005;
-pub const B576000: usize = 0o010006;
-pub const B921600: usize = 0o010007;
-pub const B1000000: usize = 0o010010;
-pub const B1152000: usize = 0o010011;
-pub const B1500000: usize = 0o010012;
-pub const B2000000: usize = 0o010013;
-pub const B2500000: usize = 0o010014;
-pub const B3000000: usize = 0o010015;
-pub const B3500000: usize = 0o010016;
-pub const B4000000: usize = 0o010017;
-
-pub const CSIZE: usize = 0o000060;
-pub const CS5: usize = 0o000000;
-pub const CS6: usize = 0o000020;
-pub const CS7: usize = 0o000040;
-pub const CS8: usize = 0o000060;
-pub const CSTOPB: usize = 0o000100;
-pub const CREAD: usize = 0o000200;
-pub const PARENB: usize = 0o000400;
-pub const PARODD: usize = 0o001000;
-pub const HUPCL: usize = 0o002000;
-pub const CLOCAL: usize = 0o004000;
-
-pub const ISIG: usize = 0o000001;
-pub const ICANON: usize = 0o000002;
-pub const ECHO: usize = 0o000010;
-pub const ECHOE: usize = 0o000020;
-pub const ECHOK: usize = 0o000040;
-pub const ECHONL: usize = 0o000100;
-pub const NOFLSH: usize = 0o000200;
-pub const TOSTOP: usize = 0o000400;
-pub const IEXTEN: usize = 0o100000;
+pub const IGNBRK: usize = 0o000_001;
+pub const BRKINT: usize = 0o000_002;
+pub const IGNPAR: usize = 0o000_004;
+pub const PARMRK: usize = 0o000_010;
+pub const INPCK: usize = 0o000_020;
+pub const ISTRIP: usize = 0o000_040;
+pub const INLCR: usize = 0o000_100;
+pub const IGNCR: usize = 0o000_200;
+pub const ICRNL: usize = 0o000_400;
+pub const IUCLC: usize = 0o001_000;
+pub const IXON: usize = 0o002_000;
+pub const IXANY: usize = 0o004_000;
+pub const IXOFF: usize = 0o010_000;
+pub const IMAXBEL: usize = 0o020_000;
+pub const IUTF8: usize = 0o040_000;
+
+pub const OPOST: usize = 0o000_001;
+pub const OLCUC: usize = 0o000_002;
+pub const ONLCR: usize = 0o000_004;
+pub const OCRNL: usize = 0o000_010;
+pub const ONOCR: usize = 0o000_020;
+pub const ONLRET: usize = 0o00_0040;
+pub const OFILL: usize = 0o000_100;
+pub const OFDEL: usize = 0o000_200;
+
+pub const VTDLY: usize = 0o040_000;
+pub const VT0: usize = 0o000_000;
+pub const VT1: usize = 0o040_000;
+
+pub const B0: usize = 0o000_000;
+pub const B50: usize = 0o000_001;
+pub const B75: usize = 0o000_002;
+pub const B110: usize = 0o000_003;
+pub const B134: usize = 0o000_004;
+pub const B150: usize = 0o000_005;
+pub const B200: usize = 0o000_006;
+pub const B300: usize = 0o000_007;
+pub const B600: usize = 0o000_010;
+pub const B1200: usize = 0o000_011;
+pub const B1800: usize = 0o000_012;
+pub const B2400: usize = 0o000_013;
+pub const B4800: usize = 0o000_014;
+pub const B9600: usize = 0o000_015;
+pub const B19200: usize = 0o000_016;
+pub const B38400: usize = 0o000_017;
+
+pub const B57600: usize = 0o010_001;
+pub const B115200: usize = 0o010_002;
+pub const B230400: usize = 0o010_003;
+pub const B460800: usize = 0o010_004;
+pub const B500000: usize = 0o010_005;
+pub const B576000: usize = 0o010_006;
+pub const B921600: usize = 0o010_007;
+pub const B1000000: usize = 0o010_010;
+pub const B1152000: usize = 0o010_011;
+pub const B1500000: usize = 0o010_012;
+pub const B2000000: usize = 0o010_013;
+pub const B2500000: usize = 0o010_014;
+pub const B3000000: usize = 0o010_015;
+pub const B3500000: usize = 0o010_016;
+pub const B4000000: usize = 0o010_017;
+
+pub const CSIZE: usize = 0o000_060;
+pub const CS5: usize = 0o000_000;
+pub const CS6: usize = 0o000_020;
+pub const CS7: usize = 0o000_040;
+pub const CS8: usize = 0o000_060;
+pub const CSTOPB: usize = 0o000_100;
+pub const CREAD: usize = 0o000_200;
+pub const PARENB: usize = 0o000_400;
+pub const PARODD: usize = 0o001_000;
+pub const HUPCL: usize = 0o002_000;
+pub const CLOCAL: usize = 0o004_000;
+
+pub const ISIG: usize = 0o000_001;
+pub const ICANON: usize = 0o000_002;
+pub const ECHO: usize = 0o000_010;
+pub const ECHOE: usize = 0o000_020;
+pub const ECHOK: usize = 0o000_040;
+pub const ECHONL: usize = 0o000_100;
+pub const NOFLSH: usize = 0o000_200;
+pub const TOSTOP: usize = 0o000_400;
+pub const IEXTEN: usize = 0o100_000;
 
 pub const TCOOFF: usize = 0;
 pub const TCOON: usize = 1;

src/header/time/mod.rs

@@ -73,13 +73,13 @@ pub struct itimerspec {
 pub struct sigevent;
 
 #[no_mangle]
-pub extern "C" fn asctime(timeptr: *const tm) -> *mut c_char {
-    unsafe { asctime_r(timeptr, transmute::<&mut _, *mut c_char>(&mut ASCTIME)) }
+pub unsafe extern "C" fn asctime(timeptr: *const tm) -> *mut c_char {
+    asctime_r(timeptr, transmute::<&mut _, *mut c_char>(&mut ASCTIME))
 }
 
 #[no_mangle]
-pub extern "C" fn asctime_r(tm: *const tm, buf: *mut c_char) -> *mut c_char {
-    let tm = unsafe { &*tm };
+pub unsafe extern "C" fn asctime_r(tm: *const tm, buf: *mut c_char) -> *mut c_char {
+    let tm = &*tm;
     let result = core::fmt::write(
         &mut platform::UnsafeStringWriter(buf as *mut u8),
         format_args!(
@@ -96,7 +96,7 @@ pub extern "C" fn asctime_r(tm: *const tm, buf: *mut c_char) -> *mut c_char {
     match result {
         Ok(_) => buf,
         Err(_) => {
-            unsafe { platform::errno = EIO };
+            platform::errno = EIO;
             core::ptr::null_mut()
         }
     }
@@ -117,7 +117,7 @@ pub extern "C" fn clock() -> clock_t {
         return -1;
     }
 
-    return ts.tv_sec * CLOCKS_PER_SEC + ts.tv_nsec / (1_000_000_000 / CLOCKS_PER_SEC);
+    ts.tv_sec * CLOCKS_PER_SEC + ts.tv_nsec / (1_000_000_000 / CLOCKS_PER_SEC)
 }
 
 // #[no_mangle]
@@ -321,9 +321,9 @@ pub unsafe extern "C" fn strftime(
         timeptr,
     );
     if ret < maxsize {
-        return ret;
+        ret
     } else {
-        return 0;
+        0
     }
 }
 
@@ -333,14 +333,12 @@ pub extern "C" fn strptime(buf: *const c_char, format: *const c_char, tm: *mut t
 }
 
 #[no_mangle]
-pub extern "C" fn time(tloc: *mut time_t) -> time_t {
+pub unsafe extern "C" fn time(tloc: *mut time_t) -> time_t {
     let mut ts = timespec::default();
     Sys::clock_gettime(CLOCK_REALTIME, &mut ts);
-    unsafe {
-        if !tloc.is_null() {
-            *tloc = ts.tv_sec
-        };
-    }
+    if !tloc.is_null() {
+        *tloc = ts.tv_sec
+    };
     ts.tv_sec
 }
 

src/header/time/strftime.rs

@@ -43,7 +43,7 @@ pub unsafe fn strftime<W: WriteByte>(w: &mut W, format: *const c_char, t: *const
                 }
             }};
         }
-        const WDAYS: [&'static str; 7] = [
+        const WDAYS: [&str; 7] = [
             "Sunday",
             "Monday",
             "Tuesday",
@@ -52,7 +52,7 @@ pub unsafe fn strftime<W: WriteByte>(w: &mut W, format: *const c_char, t: *const
             "Friday",
             "Saturday",
         ];
-        const MONTHS: [&'static str; 12] = [
+        const MONTHS: [&str; 12] = [
             "January",
             "Febuary",
             "March",

src/header/unistd/brk.rs

@@ -21,7 +21,7 @@ pub unsafe extern "C" fn brk(addr: *mut c_void) -> c_int {
 
 #[no_mangle]
 pub unsafe extern "C" fn sbrk(incr: intptr_t) -> *mut c_void {
-    if BRK == ptr::null_mut() {
+    if BRK.is_null() {
         BRK = Sys::brk(ptr::null_mut());
     }
 

src/header/unistd/mod.rs

@@ -43,8 +43,8 @@ pub extern "C" fn _exit(status: c_int) {
 }
 
 #[no_mangle]
-pub extern "C" fn access(path: *const c_char, mode: c_int) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn access(path: *const c_char, mode: c_int) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::access(path, mode)
 }
 
@@ -72,8 +72,8 @@ pub extern "C" fn alarm(seconds: c_uint) -> c_uint {
 }
 
 #[no_mangle]
-pub extern "C" fn chdir(path: *const c_char) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn chdir(path: *const c_char) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::chdir(path)
 }
 
@@ -83,8 +83,8 @@ pub extern "C" fn chroot(path: *const c_char) -> c_int {
 }
 
 #[no_mangle]
-pub extern "C" fn chown(path: *const c_char, owner: uid_t, group: gid_t) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn chown(path: *const c_char, owner: uid_t, group: gid_t) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::chown(path, owner, group)
 }
 
@@ -233,7 +233,7 @@ pub extern "C" fn getcwd(mut buf: *mut c_char, mut size: size_t) -> *mut c_char
     }
 
     let ret = Sys::getcwd(buf, size);
-    if ret == ptr::null_mut() {
+    if ret.is_null() {
         return ptr::null_mut();
     }
 
@@ -246,7 +246,7 @@ pub extern "C" fn getcwd(mut buf: *mut c_char, mut size: size_t) -> *mut c_char
         let heap_buf = unsafe { platform::alloc(len) as *mut c_char };
         for i in 0..len {
             unsafe {
-                *heap_buf.offset(i as isize) = stack_buf[i];
+                *heap_buf.add(i) = stack_buf[i];
             }
         }
         heap_buf
@@ -356,9 +356,9 @@ pub extern "C" fn lchown(path: *const c_char, owner: uid_t, group: gid_t) -> c_i
 }
 
 #[no_mangle]
-pub extern "C" fn link(path1: *const c_char, path2: *const c_char) -> c_int {
-    let path1 = unsafe { CStr::from_ptr(path1) };
-    let path2 = unsafe { CStr::from_ptr(path2) };
+pub unsafe extern "C" fn link(path1: *const c_char, path2: *const c_char) -> c_int {
+    let path1 = CStr::from_ptr(path1);
+    let path2 = CStr::from_ptr(path2);
     Sys::link(path1, path2)
 }
 
@@ -456,15 +456,15 @@ pub extern "C" fn read(fildes: c_int, buf: *const c_void, nbyte: size_t) -> ssiz
 }
 
 #[no_mangle]
-pub extern "C" fn readlink(path: *const c_char, buf: *mut c_char, bufsize: size_t) -> ssize_t {
-    let path = unsafe { CStr::from_ptr(path) };
-    let buf = unsafe { slice::from_raw_parts_mut(buf as *mut u8, bufsize as usize) };
+pub unsafe extern "C" fn readlink(path: *const c_char, buf: *mut c_char, bufsize: size_t) -> ssize_t {
+    let path = CStr::from_ptr(path);
+    let buf = slice::from_raw_parts_mut(buf as *mut u8, bufsize as usize);
     Sys::readlink(path, buf)
 }
 
 #[no_mangle]
-pub extern "C" fn rmdir(path: *const c_char) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn rmdir(path: *const c_char) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::rmdir(path)
 }
 
@@ -520,9 +520,9 @@ pub extern "C" fn swab(src: *const c_void, dest: *mut c_void, nbytes: ssize_t) {
 }
 
 #[no_mangle]
-pub extern "C" fn symlink(path1: *const c_char, path2: *const c_char) -> c_int {
-    let path1 = unsafe { CStr::from_ptr(path1) };
-    let path2 = unsafe { CStr::from_ptr(path2) };
+pub unsafe extern "C" fn symlink(path1: *const c_char, path2: *const c_char) -> c_int {
+    let path1 = CStr::from_ptr(path1);
+    let path2 = CStr::from_ptr(path2);
     Sys::symlink(path1, path2)
 }
 
@@ -587,8 +587,8 @@ pub extern "C" fn ttyname_r(fildes: c_int, name: *mut c_char, namesize: size_t)
 // }
 
 #[no_mangle]
-pub extern "C" fn unlink(path: *const c_char) -> c_int {
-    let path = unsafe { CStr::from_ptr(path) };
+pub unsafe extern "C" fn unlink(path: *const c_char) -> c_int {
+    let path = CStr::from_ptr(path);
     Sys::unlink(path)
 }
 

src/header/wchar/mod.rs

@@ -11,7 +11,7 @@ use platform::types::*;
 
 mod utf8;
 
-const WEOF: wint_t = 0xFFFFFFFFu32;
+const WEOF: wint_t = 0xFFFF_FFFFu32;
 
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -34,7 +34,7 @@ pub unsafe extern "C" fn btowc(c: c_int) -> wint_t {
         platform::errno = saved_errno;
         return WEOF;
     }
-    return wc as wint_t;
+    wc as wint_t
 }
 
 #[no_mangle]
@@ -103,9 +103,9 @@ pub unsafe extern "C" fn mbrtowc(
     }
     if s.is_null() {
         let xs: [c_char; 1] = [0];
-        return utf8::mbrtowc(pwc, &xs[0] as *const c_char, 1, ps);
+        utf8::mbrtowc(pwc, &xs[0] as *const c_char, 1, ps)
     } else {
-        return utf8::mbrtowc(pwc, s, n, ps);
+        utf8::mbrtowc(pwc, s, n, ps)
     }
 }
 
@@ -135,14 +135,14 @@ pub unsafe extern "C" fn mbsnrtowcs(
         let mut wc: wchar_t = 0;
         let amount = mbrtowc(
             &mut wc,
-            src.offset(src_offset as isize),
+            src.add(src_offset),
             src_len - src_offset,
             ps,
         );
 
         // Stop in the event a decoding error occured.
         if amount == -1isize as usize {
-            *src_ptr = src.offset(src_offset as isize);
+            *src_ptr = src.add(src_offset);
             return 1isize as usize;
         }
 
@@ -154,7 +154,7 @@ pub unsafe extern "C" fn mbsnrtowcs(
 
         // Store the decoded wide character in the destination buffer.
         if !dst_ptr.is_null() {
-            *dst_ptr.offset(dst_offset as isize) = wc;
+            *dst_ptr.add(dst_offset) = wc;
         }
 
         // Stop decoding after decoding a null character and return a NULL
@@ -170,19 +170,19 @@ pub unsafe extern "C" fn mbsnrtowcs(
         src_offset += amount;
     }
 
-    *src_ptr = src.offset(src_offset as isize);
-    return dst_offset;
+    *src_ptr = src.add(src_offset);
+    dst_offset
 }
 
 //Convert a multibyte string to a wide string
 #[no_mangle]
-pub extern "C" fn mbsrtowcs(
+pub unsafe extern "C" fn mbsrtowcs(
     dst: *mut wchar_t,
     src: *mut *const c_char,
     len: size_t,
     ps: *mut mbstate_t,
 ) -> size_t {
-    unsafe { mbsnrtowcs(dst, src, size_t::max_value(), len, ps) }
+    mbsnrtowcs(dst, src, size_t::max_value(), len, ps)
 }
 
 #[no_mangle]
@@ -247,17 +247,15 @@ pub extern "C" fn vswprintf(
 
 //widechar to multibyte
 #[no_mangle]
-pub extern "C" fn wcrtomb(s: *mut c_char, wc: wchar_t, ps: *mut mbstate_t) -> size_t {
+pub unsafe extern "C" fn wcrtomb(s: *mut c_char, wc: wchar_t, ps: *mut mbstate_t) -> size_t {
     let mut buffer: [c_char; MB_CUR_MAX as usize] = [0; MB_CUR_MAX as usize];
-    let mut wc_cpy = wc;
-    let mut s_cpy = s;
-
-    if s.is_null() {
-        wc_cpy = 0;
-        s_cpy = buffer.as_mut_ptr();
-    }
+    let (s_cpy, wc_cpy) = if s.is_null() {
+        (buffer.as_mut_ptr(), 0)
+    } else {
+        (s, wc)
+    };
 
-    unsafe { utf8::wcrtomb(s_cpy, wc_cpy, ps) }
+    utf8::wcrtomb(s_cpy, wc_cpy, ps)
 }
 
 // #[no_mangle]

src/header/wchar/utf8.rs

@@ -36,7 +36,11 @@ pub unsafe fn mbrtowc(pwc: *mut wchar_t, s: *const c_char, n: usize, ps: *mut mb
         *pwc = result;
     }
 
-    return if result != 0 { size } else { 0 };
+    if result != 0 {
+        size
+    } else {
+        0
+    }
 }
 
 //It's guaranteed that we don't have any nullpointers here

src/lib.rs

@@ -14,6 +14,12 @@
 #![feature(str_internals)]
 #![feature(thread_local)]
 
+#![allow(clippy::cast_lossless)]
+#![allow(clippy::cast_ptr_alignment)]
+#![allow(clippy::derive_hash_xor_eq)]
+#![allow(clippy::eval_order_dependence)]
+#![allow(clippy::mut_from_ref)]
+
 #[macro_use]
 extern crate alloc;
 extern crate cbitset;

src/platform/linux/signal.rs

@@ -22,13 +22,11 @@ impl PalSignal for Sys {
 
     fn raise(sig: c_int) -> c_int {
         let tid = e(unsafe { syscall!(GETTID) }) as pid_t;
-        let ret = if tid == !0 {
+        if tid == !0 {
             -1
         } else {
             e(unsafe { syscall!(TKILL, tid, sig) }) as c_int
-        };
-
-        ret
+        }
     }
 
     unsafe fn sigaction(sig: c_int, act: *const sigaction, oact: *mut sigaction) -> c_int {

src/platform/mod.rs

@@ -103,7 +103,7 @@ impl Write for StringWriter {
                 ptr::copy_nonoverlapping(buf.as_ptr(), self.0, copy_size);
                 self.1 -= copy_size;
 
-                self.0 = self.0.offset(copy_size as isize);
+                self.0 = self.0.add(copy_size);
                 *self.0 = 0;
             }
 
@@ -136,8 +136,8 @@ impl Write for UnsafeStringWriter {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         unsafe {
             ptr::copy_nonoverlapping(buf.as_ptr(), self.0, buf.len());
-            *self.0.offset(buf.len() as isize) = b'\0';
-            self.0 = self.0.offset(buf.len() as isize);
+            self.0 = self.0.add(buf.len());
+            *self.0 = b'\0';
         }
         Ok(buf.len())
     }

src/platform/rlb.rs

@@ -23,7 +23,7 @@ pub enum Line<'a> {
 impl RawLineBuffer {
     pub const fn new(fd: c_int) -> Self {
         Self {
-            fd: fd,
+            fd,
             buf: Vec::new(),
             newline: None,
             read: 0,

src/start.rs

@@ -43,20 +43,20 @@ pub unsafe extern "C" fn relibc_start(sp: &'static Stack) -> ! {
 
     let envp = sp.envp();
     let mut len = 0;
-    while *envp.offset(len) != ptr::null() {
+    while ! (*envp.add(len)).is_null() {
         len += 1;
     }
-    platform::inner_environ = Vec::with_capacity(len as usize + 1);
+    platform::inner_environ = Vec::with_capacity(len + 1);
     for i in 0..len {
-        let mut item = *envp.offset(i);
+        let mut item = *envp.add(i);
         let mut len = 0;
-        while *item.offset(len) != 0 {
+        while *item.add(len) != 0 {
             len += 1;
         }
 
-        let buf = platform::alloc(len as usize + 1) as *mut c_char;
+        let buf = platform::alloc(len + 1) as *mut c_char;
         for i in 0..=len {
-            *buf.offset(i) = *item.offset(i);
+            *buf.add(i) = *item.add(i);
         }
         platform::inner_environ.push(buf);
     }