+@@ rust/kernel/str.rs: macro_rules! c_str { + } + + #[cfg(test)] +-#[expect(clippy::items_after_test_module)] + mod tests { + use super::*; + @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { macro_rules! fmt { ($($f:tt)*) => ( core::format_args!($($f)*) ) } + ++/// Integer parsing functions for parsing signed and unsigned integers ++/// potentially prefixed with `0x`, `0o`, or `0b`. +pub mod parse_int { -+ //! Integer parsing functions for parsing signed and unsigned integers -+ //! potentially prefixed with `0x`, `0o`, or `0b`. -+ + use crate::prelude::*; + use crate::str::BStr; + use core::ops::Deref; @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // This is required because the `from_str_radix` function on the primitive + // integer types is not part of any trait. + pub trait FromStrRadix: Sized { -+ /// Parse `src` to `Self` using radix `radix`. ++ /// Parse `src` to [`Self`] using radix `radix`. + fn from_str_radix(src: &BStr, radix: u32) -> Result; + -+ /// Return the absolute value of Self::MIN. ++ /// Return the absolute value of [`Self::MIN`]. + fn abs_min() -> u64; + + /// Perform bitwise 2's complement on `self`. @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + [b'0', b'o' | b'O', rest @ ..] => (8, rest.as_ref()), + [b'0', b'b' | b'B', rest @ ..] => (2, rest.as_ref()), + // NOTE: We are including the leading zero to be able to parse -+ // literal 0 here. If we removed it as a radix prefix, we would not ++ // literal `0` here. If we removed it as a radix prefix, we would not + // be able to parse `0`. + [b'0', ..] => (8, src), + _ => (10, src), @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + /// permitted. Any string parsed by [`kstrtol()`] or [`kstrtoul()`] will be + /// successfully parsed. + /// -+ /// [`kstrtol()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtol -+ /// [`kstrtoul()`]: https://www.kernel.org/doc/html/latest/core-api/kernel-api.html#c.kstrtoul ++ /// [`kstrtol()`]: https://docs.kernel.org/core-api/kernel-api.html#c.kstrtol ++ /// [`kstrtoul()`]: https://docs.kernel.org/core-api/kernel-api.html#c.kstrtoul + /// -+ /// # Example -+ /// ``` -+ /// use kernel::str::parse_int::ParseInt; -+ /// use kernel::b_str; ++ /// # Examples + /// -+ /// assert_eq!(Ok(0), u8::from_str(b_str!("0"))); ++ /// ``` ++ /// # use kernel::str::parse_int::ParseInt; ++ /// # use kernel::b_str; ++ /// assert_eq!(Ok(0u8), u8::from_str(b_str!("0"))); + /// + /// assert_eq!(Ok(0xa2u8), u8::from_str(b_str!("0xa2"))); + /// assert_eq!(Ok(-0xa2i32), i32::from_str(b_str!("-0xa2"))); @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + /// assert_eq!(Ok(0b1001i16), i16::from_str(b_str!("0b1001"))); + /// assert_eq!(Ok(-0b1001i16), i16::from_str(b_str!("-0b1001"))); + /// -+ /// assert_eq!(Ok(127), i8::from_str(b_str!("127"))); ++ /// assert_eq!(Ok(127i8), i8::from_str(b_str!("127"))); + /// assert!(i8::from_str(b_str!("128")).is_err()); -+ /// assert_eq!(Ok(-128), i8::from_str(b_str!("-128"))); ++ /// assert_eq!(Ok(-128i8), i8::from_str(b_str!("-128"))); + /// assert!(i8::from_str(b_str!("-129")).is_err()); -+ /// assert_eq!(Ok(255), u8::from_str(b_str!("255"))); ++ /// assert_eq!(Ok(255u8), u8::from_str(b_str!("255"))); + /// assert!(u8::from_str(b_str!("256")).is_err()); + /// ``` + pub trait ParseInt: private::FromStrRadix + TryFrom { @@ rust/kernel/str.rs: fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // 2's complement values range from -2^(b-1) to 2^(b-1)-1. + // So if we want to parse negative numbers as positive and + // later multiply by -1, we have to parse into a larger -+ // integer. We choose u64 as sufficiently large. NOTE: 128 -+ // bit integers are not available on all platforms, hence -+ // the choice of 64 bit. ++ // integer. We choose `u64` as sufficiently large. ++ // ++ // NOTE: 128-bit integers are not available on all ++ // platforms, hence the choice of 64-bit. + let val = u64::from_str_radix( + core::str::from_utf8(digits).map_err(|_| EINVAL)?, + radix,