Add sprintf support.

Requires a C file as variadic functions aren't stable in Rust.

Author: thejpster

Cargo.toml

@@ -8,3 +8,16 @@ license-file = "LICENCES.md"
 readme = "README.md"
 
 [dependencies]
+
+[build-dependencies]
+cc = "1.0"
+
+[features]
+# Set this feature to assume a C `long` is 64-bits (i.e. the C compiler uses
+# the LP64 model, rather than the LLP64, ILP32 or LP32 models). See
+# https://en.cppreference.com/w/cpp/language/types for more details.
+lp64 = []
+# Set this feature to assume a C `int` is 16-bits (i.e. the C compiler uses
+# the LP32 model, rather than the LP64, LLP64 or ILP32 models). See
+# https://en.cppreference.com/w/cpp/language/types for more details.
+lp32 = []

README.md

@@ -9,6 +9,19 @@ This crate basically came about so that the [nrfxlib](https://github.com/NordicP
 ## Implemented so far
 
 * strol
+* atoi
+* strcmp
+* strncmp
+* strlen
+* strtol
+* strstr
+* snprintf
+* vsnprintf
+
+## Non-standard helper functions
+
+* itoa
+* utoa
 
 ## To Do
 

build.rs

@@ -0,0 +1,10 @@
+use cc;
+
+fn main() {
+    // Build our snprintf substitute (which has to be C as Rust doesn't do varargs)
+    cc::Build::new()
+        .warnings(true)
+        .extra_warnings(true)
+        .file("./src/snprintf.c")
+        .compile("clocal");
+}

src/atoi.rs

@@ -3,7 +3,7 @@
 //! Copyright (c) Jonathan 'theJPster' Pallant 2019
 //! Licensed under the Blue Oak Model Licence 1.0.0
 
-use crate::strtol;
+use crate::{strtol, CChar, CInt, CLong};
 
 /// Converts a null-terminated string representing a decimal integer, into an
 /// integer. No indication of error.
@@ -15,13 +15,13 @@ use crate::strtol;
 /// assert_eq!(unsafe { atoi(b"".as_ptr()) }, 0);
 /// ```
 #[no_mangle]
-pub unsafe extern "C" fn atoi(s: *const crate::CChar) -> crate::CInt {
+pub unsafe extern "C" fn atoi(s: *const CChar) -> CInt {
     let result = strtol(s);
-    if result > crate::CInt::max_value() {
-        crate::CInt::max_value()
-    } else if result < crate::CInt::min_value() {
-        crate::CInt::min_value()
+    if result > CInt::max_value() as CLong {
+        CInt::max_value()
+    } else if result < CInt::min_value() as CLong {
+        CInt::min_value()
     } else {
-        result as crate::CInt
+        result as CInt
     }
 }

src/itoa.rs

@@ -0,0 +1,234 @@
+//! Rust implementation of C library function `itoa`
+//!
+//! This function isn't part of POSIX, or the C standard library, but it is
+//! mentioned in K&R, and it useful when writing a `sprintf` implementation.
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+use crate::CChar;
+
+#[no_mangle]
+/// Formats the given value `i`, with the given radix, into the given buffer (of the given length).
+///
+/// No prefixes (like 0x or 0b) are generated. Only radix values in the range
+/// 2..=16 are supported.
+///
+/// Returns the number of bytes written on success (not including the null),
+/// or -1 if the buffer wasn't large enough.
+pub unsafe extern "C" fn itoa(i: i64, s: *mut CChar, s_len: usize, radix: u8) -> i32 {
+    let (is_negative, pos_i) = if i < 0 {
+        (true, (-i) as u64)
+    } else {
+        (false, i as u64)
+    };
+
+    if is_negative && (s_len > 0) {
+        core::ptr::write(s, b'-');
+        utoa(pos_i, s.offset(1), s_len - 1, radix)
+    } else {
+        utoa(pos_i, s, s_len, radix)
+    }
+}
+
+#[no_mangle]
+/// Formats the given value `u`, with the given radix, into the given buffer (of the given length).
+///
+/// No prefixes (like 0x or 0b) are generated. Only radix values in the range
+/// 2..=16 are supported. Negative numbers are not supported.
+///
+/// Returns the number of bytes written on success (not including the null),
+/// or -1 if the buffer wasn't large enough.
+pub unsafe extern "C" fn utoa(mut u: u64, s: *mut CChar, s_len: usize, radix: u8) -> i32 {
+    let buffer_slice = core::slice::from_raw_parts_mut(s, s_len);
+
+    // Build the number up in buffer s in reverse order
+    let mut index = 0usize;
+    for slot in buffer_slice.iter_mut() {
+        let digit = (u % radix as u64) as u8;
+        if digit <= 9 {
+            *slot = digit + b'0';
+        } else {
+            *slot = digit - 10 + b'a';
+        }
+        index += 1;
+        u /= radix as u64;
+        if u == 0 {
+            break;
+        }
+    }
+
+    if u != 0 {
+        return -1;
+    }
+
+    // Null-terminate
+    if index < buffer_slice.len() {
+        buffer_slice[index] = b'\0';
+    }
+
+    // Reverse buffer into correct order
+    buffer_slice[0..index].reverse();
+
+    index as i32
+}
+
+#[cfg(test)]
+mod test {
+    use super::{itoa, utoa};
+    use crate::strcmp::strcmp;
+
+    #[test]
+    fn zero() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { itoa(0, buf.as_mut_ptr(), buf.len(), 10) }, 1);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"0\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn one() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { itoa(1, buf.as_mut_ptr(), buf.len(), 10) }, 1);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"1\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn hundredish() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { itoa(123, buf.as_mut_ptr(), buf.len(), 10) }, 3);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"123\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn too_small() {
+        let mut buf = [b'\0'; 1];
+        assert_eq!(unsafe { itoa(10, buf.as_mut_ptr(), buf.len(), 10) }, -1);
+    }
+
+    #[test]
+    fn hex() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(
+            unsafe { itoa(0xDEADBEEF, buf.as_mut_ptr(), buf.len(), 16) },
+            8
+        );
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"deadbeef\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn octal() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { itoa(0o774, buf.as_mut_ptr(), buf.len(), 8) }, 3);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"774\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn binary() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(
+            unsafe { itoa(0b11100010, buf.as_mut_ptr(), buf.len(), 2) },
+            8
+        );
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"11100010\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn negative() {
+        let mut buf = [b'\0'; 32];
+        unsafe { itoa(-123, buf.as_mut_ptr(), buf.len(), 10) };
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"-123\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_zero() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { utoa(0, buf.as_mut_ptr(), buf.len(), 10) }, 1);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"0\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_one() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { utoa(1, buf.as_mut_ptr(), buf.len(), 10) }, 1);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"1\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_hundredish() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { utoa(123, buf.as_mut_ptr(), buf.len(), 10) }, 3);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"123\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_too_small() {
+        let mut buf = [b'\0'; 1];
+        assert_eq!(unsafe { utoa(10, buf.as_mut_ptr(), buf.len(), 10) }, -1);
+    }
+
+    #[test]
+    fn unsigned_hex() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(
+            unsafe { utoa(0xDEADBEEF, buf.as_mut_ptr(), buf.len(), 16) },
+            8
+        );
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"deadbeef\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_octal() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(unsafe { utoa(0o774, buf.as_mut_ptr(), buf.len(), 8) }, 3);
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"774\0" as *const u8) },
+            0
+        );
+    }
+
+    #[test]
+    fn unsigned_binary() {
+        let mut buf = [b'\0'; 32];
+        assert_eq!(
+            unsafe { utoa(0b11100010, buf.as_mut_ptr(), buf.len(), 2) },
+            8
+        );
+        assert_eq!(
+            unsafe { strcmp(buf.as_ptr() as *const u8, b"11100010\0" as *const u8) },
+            0
+        );
+    }
+}

src/lib.rs

@@ -31,11 +31,51 @@ pub use self::strstr::strstr;
 mod atoi;
 pub use self::atoi::atoi;
 
-// TODO: Add cfg defines / work these out for platforms other than armv6/7/8m
+mod itoa;
+pub use self::itoa::itoa;
 
+mod snprintf;
+
+/// `long long int` is always 64-bits long.
 pub type CLongLong = i64;
+
+/// `unsigned long long int` is always 64-bits long.
+pub type CULongLong = i64;
+
+#[cfg(feature = "lp64")]
+/// The `lp64` feature means we assume `long int` is 64-bits.
+pub type CLong = i64;
+
+#[cfg(feature = "lp64")]
+/// The `lp64` feature means we assume `unsigned long int` is 64-bits.
+pub type CULong = u64;
+
+#[cfg(not(feature = "lp64"))]
+/// We assume `long int` is 32-bits.
 pub type CLong = i32;
+
+#[cfg(not(feature = "lp64"))]
+/// We assume `unsigned long int` is 32-bits.
+pub type CULong = u32;
+
+#[cfg(feature = "lp32")]
+/// The `lp32` feature means we assume `int` is 16-bits.
+pub type CInt = i16;
+
+#[cfg(feature = "lp32")]
+/// The `lp32` feature means we assume `unsigned int` is 16-bits.
+pub type CUInt = u16;
+
+#[cfg(not(feature = "lp32"))]
+/// We assume `int` is 32-bits.
 pub type CInt = i32;
+
+#[cfg(not(feature = "lp32"))]
+/// We assume `unsigned int` is 32-bits.
+pub type CUInt = u32;
+
+/// Represents an 8-bit `char`. Rust does not (and will never) support
+/// platforms where `char` is not 8-bits long.
 pub type CChar = u8;
 
 /// This allows you to iterate a null-terminated string in a relatively simple