First basic implementation of a few common functions.

Author: thejpster

.gitignore

@@ -0,0 +1,3 @@
+/target
+**/*.rs.bk
+Cargo.lock

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "tinyrlibc"
+version = "0.1.0"
+authors = ["Jonathan 'theJPster' Pallant <[email protected]>"]
+edition = "2018"
+description = "Tiny, incomplete C library for bare-metal targets, written in Stable (but Unsafe) Rust"
+license-file = "LICENCES.md"
+readme = "README.md"
+
+[dependencies]

LICENCES.md

@@ -0,0 +1,55 @@
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules.  The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+<https://blueoakcouncil.org/license/1.0.0>.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice.  If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+***As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim.***

README.md

@@ -0,0 +1,21 @@
+# Tiny Rust libc
+
+## Introduction
+
+This is a _tiny_ libc implementation, mostly (but not entirely) written in the Rust programming language. It is useful for bare-metal embedded Rust applications that need a C library (maybe because of some third-party library written in C they want to use) but don't want to link against a full [newlib](https://sourceware.org/newlib), or who tried but had trouble with both newlib and [compiler_builtins](https://github.com/rust-lang-nursery/compiler-builtins) defining symbols like `memset`.
+
+This crate basically came about so that the [nrfxlib](https://github.com/NordicPlayground/nrfxlib) binary interface library for the nRF9160 would work with Rust.
+
+## Implemented so far
+
+* strol
+
+## To Do
+
+* Anything else nrfxlib needs
+* Anything anyone is prepared to submit
+
+## Licence
+
+As this is going to be a bunch of bits taken from all over the place (some newlib, some relibc, etc), each function has its own file and each file has its own licence. Any new licences should be appended to the [LICENCE.md](./LICENCE.md) file.
+

src/atoi.rs

@@ -0,0 +1,27 @@
+//! Rust implementation of C library function `atoi`
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+use crate::strtol;
+
+/// Converts a null-terminated string representing a decimal integer, into an
+/// integer. No indication of error.
+///
+/// ```
+/// use tinyrlibc::atoi;
+/// assert_eq!(unsafe { atoi(b"123".as_ptr()) }, 123);
+/// assert_eq!(unsafe { atoi(b"123x".as_ptr()) }, 123);
+/// assert_eq!(unsafe { atoi(b"".as_ptr()) }, 0);
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn atoi(s: *const crate::CChar) -> crate::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()
+    } else {
+        result as crate::CInt
+    }
+}

src/lib.rs

@@ -0,0 +1,67 @@
+//! A tiny C library, written in Rust.
+//!
+//! See README.md for more details.
+//!
+//! This file is Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+//!
+//! See each module for its respective licence.
+
+#![cfg_attr(not(test), no_std)]
+
+#[cfg(test)]
+#[allow(unused_imports)]
+use std as core;
+
+mod strcmp;
+pub use self::strcmp::strcmp;
+
+mod strncmp;
+pub use self::strncmp::strncmp;
+
+mod strlen;
+pub use self::strlen::strlen;
+
+mod strtol;
+pub use self::strtol::strtol;
+
+mod strstr;
+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
+
+pub type CLongLong = i64;
+pub type CLong = i32;
+pub type CInt = i32;
+pub type CChar = u8;
+
+/// This allows you to iterate a null-terminated string in a relatively simple
+/// way.
+pub struct CStringIter {
+    ptr: *const CChar,
+    idx: isize,
+}
+
+impl CStringIter {
+    /// Create a new iterator from a pointer to a null-terminated string. The
+    /// behaviour is undefined if the string is not null-terminated.
+    pub fn new(s: *const CChar) -> CStringIter {
+        CStringIter { ptr: s, idx: 0 }
+    }
+}
+
+impl core::iter::Iterator for CStringIter {
+    type Item = CChar;
+    fn next(&mut self) -> Option<Self::Item> {
+        let c = unsafe { *self.ptr.offset(self.idx) };
+        if c == 0 {
+            None
+        } else {
+            self.idx += 1;
+            Some(c)
+        }
+    }
+}

src/strcmp.rs

@@ -0,0 +1,19 @@
+//! Rust implementation of C library function `strncmp`
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+/// Rust implementation of C library function `strcmp`
+#[no_mangle]
+pub unsafe extern "C" fn strcmp(s1: *const crate::CChar, s2: *const crate::CChar) -> crate::CInt {
+    for i in 0.. {
+        let s1_i = s1.offset(i);
+        let s2_i = s2.offset(i);
+
+        let val = *s1_i as i32 - *s2_i as i32;
+        if val != 0 || *s1_i == 0 {
+            return i32::from(val);
+        }
+    }
+    0
+}

src/strlen.rs

@@ -0,0 +1,36 @@
+//! Rust implementation of C library function `strlen`
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+/// Rust implementation of C library function `strlen`
+#[no_mangle]
+pub unsafe extern "C" fn strlen(mut s: *const crate::CChar) -> usize {
+    let mut result = 0;
+    while *s != 0 {
+        s = s.offset(1);
+        result += 1;
+    }
+    result
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test1() {
+        assert_eq!(unsafe { strlen(b"Hello\0" as *const crate::CChar) }, 5);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(unsafe { strlen(b"\0" as *const crate::CChar) }, 0);
+    }
+
+    #[test]
+    fn test3() {
+        assert_eq!(unsafe { strlen(b"X\0" as *const crate::CChar) }, 1);
+    }
+
+}

src/strncmp.rs

@@ -0,0 +1,56 @@
+//! Rust implementation of C library function `strncmp`
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+/// Rust implementation of C library function `strncmp`. Passing NULL
+/// (core::ptr::null()) gives undefined behaviour.
+#[no_mangle]
+pub unsafe extern "C" fn strncmp(
+    s1: *const crate::CChar,
+    s2: *const crate::CChar,
+    n: usize,
+) -> crate::CInt {
+    for i in 0..n as isize {
+        let s1_i = s1.offset(i);
+        let s2_i = s2.offset(i);
+
+        let val = *s1_i as i32 - *s2_i as i32;
+        if val != 0 || *s1_i == 0 {
+            return i32::from(val);
+        }
+    }
+    0
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn matches() {
+        let a = b"123\0";
+        let b = b"1234\0";
+        let result = unsafe { strncmp(a.as_ptr(), b.as_ptr(), 3) };
+        // Match!
+        assert_eq!(result, 0);
+    }
+
+    #[test]
+    fn no_match() {
+        let a = b"123\0";
+        let b = b"x1234\0";
+        let result = unsafe { strncmp(a.as_ptr(), b.as_ptr(), 3) };
+        // No match, first string first
+        assert!(result < 0);
+    }
+
+    #[test]
+    fn no_match2() {
+        let a = b"bbbbb\0";
+        let b = b"aaaaa\0";
+        let result = unsafe { strncmp(a.as_ptr(), b.as_ptr(), 3) };
+        // No match, second string first
+        assert!(result > 0);
+    }
+}

src/strstr.rs

@@ -0,0 +1,79 @@
+//! Rust implementation of C library function `strstr`
+//!
+//! Copyright (c) Jonathan 'theJPster' Pallant 2019
+//! Licensed under the Blue Oak Model Licence 1.0.0
+
+use crate::CStringIter;
+
+/// Rust implementation of C library function `strstr`
+#[no_mangle]
+pub unsafe extern "C" fn strstr(
+    haystack: *const crate::CChar,
+    needle: *const crate::CChar,
+) -> *const crate::CChar {
+    if *needle.offset(0) == 0 {
+        return haystack;
+    }
+    for haystack_trim in (0..).map(|idx| haystack.offset(idx)) {
+        if *haystack_trim == 0 {
+            break;
+        }
+        let mut len = 0;
+        for (inner_idx, nec) in CStringIter::new(needle).enumerate() {
+            let hsc = *haystack_trim.offset(inner_idx as isize);
+            if hsc != nec {
+                break;
+            }
+            len += 1;
+        }
+        if *needle.offset(len) == 0 {
+            return haystack_trim;
+        }
+    }
+    core::ptr::null()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn no_match() {
+        let needle = b"needle\0".as_ptr();
+        let haystack = b"haystack\0".as_ptr();
+        let result = unsafe { strstr(haystack, needle) };
+        assert_eq!(result, core::ptr::null());
+    }
+
+    #[test]
+    fn start() {
+        let needle = b"hay\0".as_ptr();
+        let haystack = b"haystack\0".as_ptr();
+        let result = unsafe { strstr(haystack, needle) };
+        assert_eq!(result, haystack);
+    }
+
+    #[test]
+    fn middle() {
+        let needle = b"yst\0".as_ptr();
+        let haystack = b"haystack\0".as_ptr();
+        let result = unsafe { strstr(haystack, needle) };
+        assert_eq!(result, unsafe { haystack.offset(2) });
+    }
+
+    #[test]
+    fn end() {
+        let needle = b"stack\0".as_ptr();
+        let haystack = b"haystack\0".as_ptr();
+        let result = unsafe { strstr(haystack, needle) };
+        assert_eq!(result, unsafe { haystack.offset(3) });
+    }
+
+    #[test]
+    fn partial() {
+        let needle = b"haystacka\0".as_ptr();
+        let haystack = b"haystack\0".as_ptr();
+        let result = unsafe { strstr(haystack, needle) };
+        assert_eq!(result, core::ptr::null());
+    }
+}