Code formatting

Author: eldruin

src/strcpy.rs

@@ -7,42 +7,39 @@ use crate::CChar;
 /// Rust implementation of C library function `strcpy`. Passing NULL
 /// (core::ptr::null()) gives undefined behaviour.
 #[no_mangle]
-pub unsafe extern "C" fn strcpy(
-    dest: *mut CChar,
-    src: *const CChar,
-) -> *const CChar {
-    let mut i = 0;
-    loop {
-        *dest.offset(i) = *src.offset(i);
-        let c = *dest.offset(i);
-        if c == 0 {
-            break;
-        }
-        i += 1;
-    }
-    dest
+pub unsafe extern "C" fn strcpy(dest: *mut CChar, src: *const CChar) -> *const CChar {
+	let mut i = 0;
+	loop {
+		*dest.offset(i) = *src.offset(i);
+		let c = *dest.offset(i);
+		if c == 0 {
+			break;
+		}
+		i += 1;
+	}
+	dest
 }
 
 #[cfg(test)]
 mod test {
-    use super::*;
+	use super::*;
 
-    #[test]
-    fn short() {
-        let src = b"hi\0";
-        let mut dest = *b"abcdef"; // no null terminator
-        let result = unsafe { strcpy(dest.as_mut_ptr(), src.as_ptr()) };
-        assert_eq!(
-            unsafe { core::slice::from_raw_parts(result, 5) },
-            *b"hi\0de"
-        );
-    }
+	#[test]
+	fn short() {
+		let src = b"hi\0";
+		let mut dest = *b"abcdef"; // no null terminator
+		let result = unsafe { strcpy(dest.as_mut_ptr(), src.as_ptr()) };
+		assert_eq!(
+			unsafe { core::slice::from_raw_parts(result, 5) },
+			*b"hi\0de"
+		);
+	}
 
-    #[test]
-    fn two() {
-        let src = b"hi\0";
-        let mut dest = [0u8; 2]; // no space for null terminator
-        let result = unsafe { strcpy(dest.as_mut_ptr(), src.as_ptr()) };
-        assert_eq!(unsafe { core::slice::from_raw_parts(result, 2) }, b"hi");
-    }
+	#[test]
+	fn two() {
+		let src = b"hi\0";
+		let mut dest = [0u8; 2]; // no space for null terminator
+		let result = unsafe { strcpy(dest.as_mut_ptr(), src.as_ptr()) };
+		assert_eq!(unsafe { core::slice::from_raw_parts(result, 2) }, b"hi");
+	}
 }

src/strtoul.rs

@@ -3,7 +3,7 @@
 //! Copyright (c) Jonathan 'theJPster' Pallant 2019
 //! Licensed under the Blue Oak Model Licence 1.0.0
 
-use crate::{CChar, CULong, CStringIter};
+use crate::{CChar, CStringIter, CULong};
 
 /// Rust implementation of C library function `strtoul`.
 ///
@@ -13,56 +13,55 @@ use crate::{CChar, CULong, CStringIter};
 /// function returns zero.
 #[no_mangle]
 pub unsafe extern "C" fn strtoul(s: *const CChar) -> CULong {
-    let mut result: CULong = 0;
-    for c in CStringIter::new(s) {
-        if c >= b'0' && c <= b'9' {
-            result *= 10;
-            result += (c - b'0') as CULong;
-        } else {
-            break;
-        }
-    }
-    result
+	let mut result: CULong = 0;
+	for c in CStringIter::new(s) {
+		if c >= b'0' && c <= b'9' {
+			result *= 10;
+			result += (c - b'0') as CULong;
+		} else {
+			break;
+		}
+	}
+	result
 }
 
 #[cfg(test)]
 mod test {
-    use super::strtoul;
+	use super::strtoul;
 
-    #[test]
-    fn empty() {
-        let result = unsafe { strtoul(b"\0".as_ptr()) };
-        assert_eq!(result, 0);
-    }
+	#[test]
+	fn empty() {
+		let result = unsafe { strtoul(b"\0".as_ptr()) };
+		assert_eq!(result, 0);
+	}
 
-    #[test]
-    fn non_digit() {
-        let result = unsafe { strtoul(b"1234x\0".as_ptr()) };
-        assert_eq!(result, 1234);
-    }
+	#[test]
+	fn non_digit() {
+		let result = unsafe { strtoul(b"1234x\0".as_ptr()) };
+		assert_eq!(result, 1234);
+	}
 
-    #[test]
-    fn bad_number() {
-        let result = unsafe { strtoul(b"x\0".as_ptr()) };
-        assert_eq!(result, 0);
-    }
+	#[test]
+	fn bad_number() {
+		let result = unsafe { strtoul(b"x\0".as_ptr()) };
+		assert_eq!(result, 0);
+	}
 
-    #[test]
-    fn one() {
-        let result = unsafe { strtoul(b"1\0".as_ptr()) };
-        assert_eq!(result, 1);
-    }
+	#[test]
+	fn one() {
+		let result = unsafe { strtoul(b"1\0".as_ptr()) };
+		assert_eq!(result, 1);
+	}
 
-    #[test]
-    fn hundredish() {
-        let result = unsafe { strtoul(b"123\0".as_ptr()) };
-        assert_eq!(result, 123);
-    }
-
-    #[test]
-    fn big_long() {
-        let result = unsafe { strtoul(b"2147483647\0".as_ptr()) };
-        assert_eq!(result, 2147483647);
-    }
+	#[test]
+	fn hundredish() {
+		let result = unsafe { strtoul(b"123\0".as_ptr()) };
+		assert_eq!(result, 123);
+	}
 
+	#[test]
+	fn big_long() {
+		let result = unsafe { strtoul(b"2147483647\0".as_ptr()) };
+		assert_eq!(result, 2147483647);
+	}
 }