Add rand, srand, and rand_r implementations

Cargo.toml

@@ -29,6 +29,7 @@ all = [
     "itoa",
     "memchr",
     "qsort",
+    "rand_r",
     "snprintf",
     "strcat",
     "strchr",
@@ -59,6 +60,9 @@ isupper = []
 itoa = []
 memchr = []
 qsort = []
+rand_r = []
+rand = ["rand_r", "dep:portable-atomic"]
+rand-cs = ["rand", "portable-atomic/critical-section"]
 signal = ["dep:portable-atomic"]
 signal-cs = ["portable-atomic/critical-section"]
 snprintf = []

README.md

@@ -35,6 +35,7 @@ This crate basically came about so that the [nrfxlib](https://github.com/NordicP
 * snprintf
 * vsnprintf
 * qsort
+* rand
 * alloc (optional)
     * malloc
     * calloc
@@ -49,6 +50,7 @@ This crate basically came about so that the [nrfxlib](https://github.com/NordicP
 
 * itoa
 * utoa
+* rand_r
 
 ## To Do
 

src/lib.rs

@@ -26,6 +26,14 @@ mod abs;
 #[cfg(feature = "abs")]
 pub use self::abs::abs;
 
+mod rand_r;
+#[cfg(feature = "rand_r")]
+pub use self::rand_r::{rand_r, RAND_MAX};
+#[cfg(feature = "rand")]
+mod rand;
+#[cfg(feature = "rand")]
+pub use self::rand::{rand, srand};
+
 mod strcmp;
 #[cfg(feature = "strcmp")]
 pub use self::strcmp::strcmp;

src/rand.rs

@@ -0,0 +1,64 @@
+//! Rust implementation of C library functions `rand` and `srand`
+//!
+//! Licensed under the Blue Oak Model Licence 1.0.0
+use core::{
+	ffi::{c_int, c_uint},
+	sync::atomic::Ordering,
+};
+
+use portable_atomic::AtomicU32;
+
+// static mut RAND: Option<GnuRand> = None;
+static RAND_STATE: AtomicU32 = AtomicU32::new(0x0);
+
+/// Rust implementation of C library function `srand`
+#[cfg_attr(feature = "rand", no_mangle)]
+pub extern "C" fn srand(seed: c_uint) {
+	RAND_STATE.store(seed, Ordering::Release);
+}
+
+/// Rust implementation of C library function `rand`.
+///
+/// Returns a pseudo-random integer in the range 0 to [`RAND_MAX`](crate::RAND_MAX) (inclusive).
+/// This requires CAS operations. If your platform does not support them natively,
+/// you either have to enable the `rand-cs` feature of `tinyrlibc`,
+/// or the [`critical-section`](https://docs.rs/portable-atomic/1.9.0/portable_atomic/#optional-features-critical-section) feature,
+/// or the [`unsafe-assume-single-core`](https://docs.rs/portable-atomic/1.9.0/portable_atomic/#optional-features-unsafe-assume-single-core) feature
+/// in [`portable-atomic`](https://crates.io/crates/portable-atomic).
+#[cfg_attr(feature = "rand", no_mangle)]
+pub extern "C" fn rand() -> c_int {
+	let mut current_state = RAND_STATE.load(Ordering::Relaxed);
+	let mut new_state = current_state;
+	let mut result = unsafe { crate::rand_r(&mut new_state as *mut _) };
+
+	loop {
+		match RAND_STATE.compare_exchange_weak(
+			current_state,
+			new_state,
+			Ordering::SeqCst,
+			Ordering::Relaxed,
+		) {
+			Ok(_) => break,
+			Err(c) => current_state = c,
+		}
+		new_state = current_state;
+		result = unsafe { crate::rand_r(&mut new_state as *mut _) };
+	}
+
+	result as _
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	#[test]
+	fn test_rand() {
+		assert_eq!(rand(), 1012483);
+		assert_eq!(rand(), 1716955678);
+		assert_eq!(rand(), 1792309081);
+		srand(5);
+		assert_eq!(rand(), 234104183);
+		assert_eq!(rand(), 1214203243);
+		assert_eq!(rand(), 1803669307);
+	}
+}

src/rand_r.rs

@@ -0,0 +1,52 @@
+//! Rust implementation of C library function `rand_r`
+//!
+//! Licensed under the Blue Oak Model Licence 1.0.0
+use core::ffi::{c_int, c_uint};
+
+#[cfg_attr(not(feature = "rand_r"), export_name = "tinyrlibc_RAND_MAX")]
+#[cfg_attr(feature = "rand_r", no_mangle)]
+pub static RAND_MAX: c_int = 0x7FFF_FFFC as _;
+
+/// Rust implementation of C library function `rand_r`
+///
+/// Passing NULL (core::ptr::null()) gives undefined behaviour.
+#[cfg_attr(not(feature = "rand_r"), export_name = "tinyrlibc_rand_r")]
+#[cfg_attr(feature = "rand_r", no_mangle)]
+pub unsafe extern "C" fn rand_r(seedp: *mut c_uint) -> c_int {
+	// This algorithm is mentioned in the ISO C standard, here extended for 32 bits.
+	let mut next = *seedp;
+	let mut result: c_int;
+
+	next = next.wrapping_mul(1103515245);
+	next = next.wrapping_add(12345);
+	result = ((next / 65536) % 2048) as c_int;
+
+	next = next.wrapping_mul(1103515245);
+	next = next.wrapping_add(12345);
+	result <<= 10;
+	result ^= ((next / 65536) % 1024) as c_int;
+
+	next = next.wrapping_mul(1103515245);
+	next = next.wrapping_add(12345);
+	result <<= 10;
+	result ^= ((next / 65536) % 1024) as c_int;
+
+	*seedp = next;
+
+	result - 1
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	#[test]
+	fn test_rand_r() {
+		unsafe {
+			let mut seed = 5;
+			// Values taken from glibc implementation
+			assert_eq!(rand_r(&mut seed), 234104183);
+			assert_eq!(rand_r(&mut seed), 1214203243);
+			assert_eq!(rand_r(&mut seed), 1803669307);
+		}
+	}
+}