Allow RAND_MAX to be set to 32767.

Might be useful if your newlib assumes that, even with 32-bit integers.

Also adds "rand" to list of features in "all" and fixes missing portable-atomic.

Author: jonathanpallant

Cargo.toml

@@ -30,6 +30,7 @@ all = [
     "memchr",
     "qsort",
     "rand_r",
+    "rand",
     "snprintf",
     "strcat",
     "strchr",
@@ -61,7 +62,8 @@ itoa = []
 memchr = []
 qsort = []
 rand_r = []
-rand = ["rand_r"]
+rand = ["rand_r", "dep:portable-atomic"]
+rand_max_i16 = []
 signal = ["dep:portable-atomic"]
 signal-cs = ["portable-atomic/critical-section"]
 snprintf = []

src/rand.rs

@@ -2,7 +2,7 @@
 //!
 //! Licensed under the Blue Oak Model Licence 1.0.0
 use core::{
-	ffi::{c_int, c_uint},
+	ffi::{c_int, c_uint, c_ulong},
 	sync::atomic::Ordering,
 };
 
@@ -13,15 +13,18 @@ static RAND_STATE: AtomicU32 = AtomicU32::new(1);
 /// 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::Relaxed);
+	// we do this cast to support platforms where c_uint is u16.
+	// but it complains on platforms where c_uint is u32.
+	#[allow(clippy::unnecessary_cast)]
+	RAND_STATE.store(seed as u32, Ordering::Relaxed);
 }
 
 /// Rust implementation of C library function `rand`.
 #[cfg_attr(feature = "rand", no_mangle)]
 pub extern "C" fn rand() -> c_int {
-	let mut state = RAND_STATE.load(Ordering::Relaxed);
+	let mut state = RAND_STATE.load(Ordering::Relaxed) as c_ulong;
 	let result = unsafe { crate::rand_r(&mut state) };
-	RAND_STATE.store(state);
+	RAND_STATE.store(state as u32, Ordering::Relaxed);
 	result
 }
 
@@ -30,12 +33,24 @@ mod test {
 	use super::*;
 	#[test]
 	fn test_rand() {
-		assert_eq!(rand(), 1012484);
-		assert_eq!(rand(), 1716955679);
-		assert_eq!(rand(), 1792309082);
-		srand(5);
-		assert_eq!(rand(), 234104184);
-		assert_eq!(rand(), 1214203244);
-		assert_eq!(rand(), 1803669308);
+		if c_int::MAX == 32767 || cfg!(feature = "rand_max_i16") {
+			srand(1);
+			assert_eq!(rand(), 16838);
+			assert_eq!(rand(), 5758);
+			assert_eq!(rand(), 10113);
+			srand(5);
+			assert_eq!(rand(), 18655);
+			assert_eq!(rand(), 8457);
+			assert_eq!(rand(), 10616);
+		} else {
+			srand(1);
+			assert_eq!(rand(), 476707713);
+			assert_eq!(rand(), 1186278907);
+			assert_eq!(rand(), 505671508);
+			srand(5);
+			assert_eq!(rand(), 234104184);
+			assert_eq!(rand(), 1214203244);
+			assert_eq!(rand(), 1803669308);
+		}
 	}
 }

src/rand_r.rs

@@ -1,7 +1,7 @@
 //! 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};
+use core::ffi::{c_int, c_uint, c_ulong};
 
 #[cfg_attr(not(feature = "rand_r"), export_name = "tinyrlibc_RAND_MAX")]
 #[cfg_attr(feature = "rand_r", no_mangle)]
@@ -12,21 +12,21 @@ pub static RAND_MAX: c_int = c_int::MAX;
 /// 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 {
-	let mut result;
+pub unsafe extern "C" fn rand_r(seedp: *mut c_ulong) -> c_int {
+	let mut result: c_ulong;
 
-	fn pump(input: c_uint) -> c_uint {
+	fn pump(input: c_ulong) -> c_ulong {
 		// This algorithm is mentioned in the ISO C standard
 		input.wrapping_mul(1103515245).wrapping_add(12345)
 	}
 
-	fn select_top(state: c_uint, bits: usize) -> c_uint {
+	fn select_top(state: c_ulong, bits: usize) -> c_ulong {
 		// ignore the lower 16 bits, as they are low quality
 		(state >> 16) & ((1 << bits) - 1)
 	}
 
 	let mut next = *seedp;
-	if c_int::MAX == 32767 {
+	if c_int::MAX == 32767 || cfg!(feature = "rand_max_i16") {
 		// pull 15 bits in one go
 		next = pump(next);
 		result = select_top(next, 15);
@@ -49,11 +49,20 @@ mod test {
 	use super::*;
 	#[test]
 	fn test_rand_r() {
-		unsafe {
-			let mut seed = 5;
-			assert_eq!(rand_r(&mut seed), 234104184);
-			assert_eq!(rand_r(&mut seed), 1214203244);
-			assert_eq!(rand_r(&mut seed), 1803669308);
+		if c_int::MAX == 32767 || cfg!(feature = "rand_max_i16") {
+			unsafe {
+				let mut seed = 5;
+				assert_eq!(rand_r(&mut seed), 18655);
+				assert_eq!(rand_r(&mut seed), 8457);
+				assert_eq!(rand_r(&mut seed), 10616);
+			}
+		} else {
+			unsafe {
+				let mut seed = 5;
+				assert_eq!(rand_r(&mut seed), 234104184);
+				assert_eq!(rand_r(&mut seed), 1214203244);
+				assert_eq!(rand_r(&mut seed), 1803669308);
+			}
 		}
 	}
 }