typo and grammar fix

Co-authored-by: Miguel Ojeda <[email protected]>

Author: nbdd0121

rust/kernel/str.rs

@@ -35,7 +35,7 @@ macro_rules! b_str {
 /// Possible errors when using conversion functions in [`CStr`] and [`CBoundedStr`].
 #[derive(Debug, Clone, Copy)]
 pub enum CStrConvertError {
-    /// Supplied string length exceed the bound specified. Only happen when
+    /// Supplied string length exceeds the specified bound. Only happens when
     /// constructing a [`CBoundedStr`].
     BoundExceeded,
 
@@ -254,10 +254,10 @@ macro_rules! c_str {
 }
 
 /// A `NUL`-terminated string that is guaranteed to be shorter than a given
-/// length. This type is useful because C-side usually impose maximum length
+/// length. This type is useful because the C side usually imposes a maximum length
 /// on types.
 ///
-/// The size parameter `N` represent the maximum number of bytes including NUL.
+/// The size parameter `N` represents the maximum number of bytes including `NUL`.
 /// This implies that even though `CBoundedStr<0>` is a well-formed type it cannot
 /// be safely created.
 #[repr(transparent)]
@@ -266,7 +266,7 @@ pub struct CBoundedStr<const N: usize>(CStr);
 impl<const N: usize> CBoundedStr<N> {
     /// Creates a [`CBoundedStr`] from a [`CStr`].
     ///
-    /// The provided `CStr` must be shorten than `N`.
+    /// The provided [`CStr`] must be shorter than `N`.
     #[inline]
     pub const fn from_c_str(c_str: &CStr) -> Result<&Self, CStrConvertError> {
         if c_str.len_with_nul() > N {
@@ -282,16 +282,16 @@ impl<const N: usize> CBoundedStr<N> {
     ///
     /// # Safety
     ///
-    /// The provided CStr must be shorten than `N`.
+    /// The provided [`CStr`] must be shorter than `N`.
     #[inline]
     pub const unsafe fn from_c_str_unchecked(c_str: &CStr) -> &Self {
         &*(c_str as *const CStr as *const Self)
     }
 
     /// Creates a [`CBoundedStr`] from a `[u8]`.
     ///
-    /// The provided slice must be nul-terminated, does not contain any
-    /// interior nul bytes and be shorten than `N`.
+    /// The provided slice must be `NUL`-terminated, must not contain any
+    /// interior `NUL` bytes and must be shorter than `N`.
     #[inline]
     pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&Self, CStrConvertError> {
         Self::from_c_str(CStr::from_bytes_with_nul(bytes)?)
@@ -302,8 +302,8 @@ impl<const N: usize> CBoundedStr<N> {
     ///
     /// # Safety
     ///
-    /// The provided slice must be nul-terminated, does not contain any
-    /// interior nul bytes and be shorten than `N`.
+    /// The provided slice must be `NUL`-terminated, must not contain any
+    /// interior `NUL` bytes and must be shorter than `N`.
     #[inline]
     pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &Self {
         Self::from_c_str_unchecked(CStr::from_bytes_with_nul_unchecked(bytes))
@@ -314,7 +314,7 @@ impl<const N: usize> CBoundedStr<N> {
     ///
     /// # Safety
     ///
-    /// The provided slice must be nul-terminated.
+    /// The provided slice must be `NUL`-terminated.
     #[inline]
     pub const unsafe fn from_exact_bytes_with_nul_unchecked(bytes: &[u8; N]) -> &Self {
         Self::from_bytes_with_nul_unchecked(bytes)
@@ -329,8 +329,8 @@ impl<const N: usize> CBoundedStr<N> {
         unsafe { CBoundedStr::<M>::from_c_str_unchecked(&self.0) }
     }
 
-    /// Converts the string to a c_char array with the current bound, fills the
-    /// remaining bytes with zero.
+    /// Converts the string to a `c_char` array of the same bound, filling
+    /// the remaining bytes with zero.
     #[inline]
     pub const fn to_char_array(&self) -> [c_types::c_char; N] {
         let mut ret: [c_types::c_char; N] = [0; N];
@@ -342,7 +342,8 @@ impl<const N: usize> CBoundedStr<N> {
         ret
     }
 
-    /// Expands the string a c_char array, fills remaining bytes with zero.
+    /// Expands the string to a `c_char` array of higher bound, filling
+    /// the remaining bytes with zero.
     ///
     /// `M` must be no less than the bound `N`.
     #[inline]
@@ -388,7 +389,7 @@ where
 
 /// Creates a new [`CBoundedStr`] from a string literal.
 ///
-/// The string literal should not contain any `NUL` bytes, and its length with NUL should not
+/// The string literal should not contain any `NUL` bytes, and its length with `NUL` should not
 /// exceed the bound supplied.
 ///
 /// # Examples
@@ -399,15 +400,15 @@ where
 /// ```
 ///
 /// ```rust,compile_fail
-/// // This would not compile as the type is `CBoundedStr<17>`.
+/// // This does not compile as the inferred type is `CBoundedStr<17>`.
 /// const MY_CSTR: &'static CBoundedStr<100> = c_bounded_str!("My awesome CStr!");
 /// ```
 ///
 /// ```rust,no_run
 /// // You can relax the bound using the `relax_bound` method.
 /// const MY_CSTR: &'static CBoundedStr<100> = c_bounded_str!("My awesome CStr!").relax_bound();
 ///
-/// // Or alternatively specify a bound when invoking macro.
+/// // Or alternatively specify a bound.
 /// // In this case the supplied bound must be a constant expression.
 /// const MY_CSTR2: &'static CBoundedStr<100> = c_bounded_str!(100, "My awesome CStr!");
 ///
@@ -416,9 +417,9 @@ where
 /// ```
 ///
 /// ```rust,compile_fail
-/// // shouldn't compile as the string is longer than the specified bound.
-/// const MY_CSTR: &'static CBoundedStr<10> = c_bounded_str!(10, "My awesome CStr!");
-/// const MY_CSTR2: &'static CBoundedStr<10> = c_bounded_str!(_, "My awesome CStr!");
+/// // These do not compile as the string is longer than the specified bound.
+/// const MY_CSTR: &'static CBoundedStr<4> = c_bounded_str!(4, "My awesome CStr!");
+/// const MY_CSTR2: &'static CBoundedStr<4> = c_bounded_str!(_, "My awesome CStr!");
 /// ```
 #[macro_export]
 macro_rules! c_bounded_str {