fix notes

Author: foxg1ove1

components/rust/core/rust_cmd.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2024, RT-Thread Development Team
+ * Copyright (c) 2006-2025, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -32,4 +32,4 @@ static int rust_component_init(void)
 }
 #ifdef RUST_INIT_COMPONENT
 INIT_APP_EXPORT(rust_component_init);
-#endif
+#endif

components/rust/core/src/allocator.rs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2024, RT-Thread Development Team
+ * Copyright (c) 2006-2025, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -14,30 +14,20 @@ use crate::panic::panic_on_atomic_context;
 use core::ptr;
 use core::ffi::c_void;
 
-/// RT-Thread global allocator implementation
-/// 
-/// This allocator provides a safe interface to RT-Thread's memory management
-/// system, supporting both regular and aligned allocations.
 pub struct RttAlloc;
-
 unsafe impl GlobalAlloc for RttAlloc {
-    /// Allocate memory with the given layout
-    /// 
-    /// # Safety
-    /// This function is unsafe as required by the GlobalAlloc trait.
-    /// The caller must ensure proper usage according to GlobalAlloc requirements.
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         panic_on_atomic_context("alloc");
         let size = layout.size();
         let align = layout.align();
 
-        // Handle zero-sized allocations
+        /* Handle zero-sized allocations */
         if size == 0 {
             return ptr::null_mut();
         }
 
-        // Use aligned allocation if alignment is greater than default
-        // RT-Thread's default alignment is typically 4 or 8 bytes
+        /* Use aligned allocation if alignment is greater than default
+         * RT-Thread's default alignment is typically 4 or 8 bytes */
         if align > 8 {
             match mem_alloc_aligned(size, align) {
                 Some(ptr) => ptr as *mut u8,
@@ -51,12 +41,6 @@ unsafe impl GlobalAlloc for RttAlloc {
         }
     }
 
-    /// Deallocate memory at the given pointer with the given layout
-    /// 
-    /// # Safety
-    /// This function is unsafe as required by the GlobalAlloc trait.
-    /// The caller must ensure the pointer was allocated by this allocator
-    /// and the layout matches the original allocation.
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
         panic_on_atomic_context("dealloc");
         if ptr.is_null() {
@@ -65,53 +49,45 @@ unsafe impl GlobalAlloc for RttAlloc {
 
         let align = layout.align();
 
-        // Use aligned deallocation if the original allocation was aligned
+        /* Use aligned deallocation if the original allocation was aligned */
         if align > 8 {
             mem_free_aligned(ptr as *mut c_void);
         } else {
             mem_free(ptr as *mut c_void);
         }
     }
 
-    /// Reallocate memory
-    /// 
-    /// # Safety
-    /// This function is unsafe as required by the GlobalAlloc trait.
-    /// The caller must ensure proper usage according to GlobalAlloc requirements.
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
         panic_on_atomic_context("realloc");
-        // Handle zero-sized new allocation
+        /* Handle zero-sized new allocation */  
         if new_size == 0 {
             self.dealloc(ptr, layout);
             return ptr::null_mut();
         }
 
-        // Handle null pointer (equivalent to alloc)
+        /* Handle null pointer (equivalent to alloc) */
         if ptr.is_null() {
             let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
             return self.alloc(new_layout);
         }
 
-        // For aligned allocations, we need to handle realloc manually
-        // since RT-Thread's rt_realloc may not preserve alignment
+        /* For aligned allocations, we need to handle realloc manually
+         * since RT-Thread's rt_realloc may not preserve alignment */
         let align = layout.align();
         if align > 8 {
-            // Allocate new aligned memory
             let new_ptr = match mem_alloc_aligned(new_size, align) {
                 Some(ptr) => ptr as *mut u8,
                 None => return ptr::null_mut(),
             };
 
-            // Copy data from old to new
+            /* Copy data from old to new */ 
             let copy_size = core::cmp::min(layout.size(), new_size);
             ptr::copy_nonoverlapping(ptr, new_ptr, copy_size);
 
-            // Free old memory
             mem_free_aligned(ptr as *mut c_void);
 
             new_ptr
         } else {
-            // Use RT-Thread's realloc for regular allocations
             match mem_realloc(ptr as *mut c_void, new_size) {
                 Some(new_ptr) => new_ptr as *mut u8,
                 None => ptr::null_mut(),

components/rust/core/src/api/base.rs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2024, RT-Thread Development Team
+ * Copyright (c) 2006-2025, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -9,7 +9,7 @@
  */
 use crate::bindings::*;
 
-// Error type from rt-thread `c code`
+/* Error type from rt-thread C code */
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum RttCResult {
     Ok = RT_EOK as isize,
@@ -26,7 +26,7 @@ pub enum RttCResult {
 
     NotValidCode = -100,
 }
-// NOTE Match to `enum Error`
+/* NOTE Match to `enum Error` */
 impl From<i32> for RttCResult {
     fn from(a: i32) -> Self {
         let ret = match a {
@@ -75,4 +75,4 @@ pub fn is_eok(val: RttCResult) -> bool {
     } else {
         false
     }
-}
+}

components/rust/core/src/api/interrupt.rs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2024, RT-Thread Development Team
+ * Copyright (c) 2006-2025, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *

components/rust/core/src/api/libloading.rs

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2024, RT-Thread Development Team
+ * Copyright (c) 2006-2025, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -8,8 +8,9 @@
  * 2025-10-14     foxglove     libdl safe wrapper (libloading-like)
  */
 
-//! Minimal `libloading`-style safe wrapper around RT-Thread libdl.
-//! Provides RAII `Library` and typed `Symbol<T>` for dlsym.
+/*! Minimal `libloading`-style safe wrapper around RT-Thread libdl.
+Provides RAII `Library` and typed `Symbol<T>` for dlsym.
+*/
 
 extern crate alloc;
 
@@ -26,13 +27,13 @@ use crate::bindings::libc;
 
 pub use crate::bindings::libc::{RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW};
 
-/// Error type for dynamic loading operations
+/* Error type for dynamic loading operations */
 pub enum DlError {
-    /// dlopen failed; contains last error C-string pointer
+    /* dlopen failed; contains last error C-string pointer */
     Open(*const c_char),
-    /// dlsym failed; contains last error C-string pointer
+    /* dlsym failed; contains last error C-string pointer */
     Symbol(*const c_char),
-    /// dlclose returned non-zero; contains return code
+    /* dlclose returned non-zero; contains return code */
     Close(c_int),
 }
 
@@ -64,27 +65,27 @@ impl core::fmt::Display for DlError {
     }
 }
 
-/// RAII wrapper for a `dlopen` handle
+/* RAII wrapper for a `dlopen` handle */
 pub struct Library {
     handle: *mut c_void,
 }
 
 impl Library {
-    /// Create a new library using default flags (`RTLD_NOW | RTLD_GLOBAL`).
-    /// Accepts a Rust string path and converts internally to a C string.
+    /* Create a new library using default flags (`RTLD_NOW | RTLD_GLOBAL`).
+     * Accepts a Rust string path and converts internally to a C string.
+     */
     pub fn new(path: &str) -> Result<Self, DlError> {
-        // Convert to NUL-terminated C string; reject interior NULs
         let cstr = match CString::new(path) {
             Ok(s) => s,
             Err(_) => {
-                // Interior NUL; no last_error available, return a neutral error
                 return Err(DlError::Open(core::ptr::null()));
             }
         };
         unsafe { Self::open_global(cstr.as_ptr()) }
     }
-    /// Open a dynamic module with given flags
-    /// Safety: `path` must be a valid, NUL-terminated C string pointer
+    /* Open a dynamic module with given flags
+     * Safety: `path` must be a valid, NUL-terminated C string pointer
+     */
     pub unsafe fn open(path: *const c_char, flags: c_int) -> Result<Self, DlError> {
         let h = libc::dlopen(path, flags);
         if h.is_null() {
@@ -94,13 +95,14 @@ impl Library {
         }
     }
 
-    /// Convenience open using `RTLD_NOW | RTLD_GLOBAL`
+    /* Convenience open using `RTLD_NOW | RTLD_GLOBAL` */
     pub unsafe fn open_global(path: *const c_char) -> Result<Self, DlError> {
         Self::open(path, RTLD_NOW | RTLD_GLOBAL)
     }
 
-    /// Resolve a typed symbol from the library using a C string pointer.
-    /// Safety: Caller must ensure `T` matches the actual symbol type and `symbol` is NUL-terminated.
+    /* Resolve a typed symbol from the library using a C string pointer.
+     * Safety: Caller must ensure `T` matches the actual symbol type and `symbol` is NUL-terminated.
+     */
     pub unsafe fn get_ptr<T>(&self, symbol: *const c_char) -> Result<Symbol<'_, T>, DlError> {
         let sym = libc::dlsym(self.handle, symbol);
         if sym.is_null() {
@@ -114,8 +116,9 @@ impl Library {
         }
     }
 
-    /// Resolve a typed symbol from the library using a byte slice name.
-    /// If the slice is not NUL-terminated, a temporary buffer is allocated.
+    /* Resolve a typed symbol from the library using a byte slice name.
+     * If the slice is not NUL-terminated, a temporary buffer is allocated.
+     */
     pub fn get<T>(&self, symbol: &[u8]) -> Result<Symbol<'_, T>, DlError> {
         let (ptr, _guard_buf): (*const c_char, Option<Vec<u8>>) = if symbol.last().copied() == Some(0) {
             (symbol.as_ptr() as *const c_char, None)
@@ -125,7 +128,6 @@ impl Library {
             buf.push(0);
             (buf.as_ptr() as *const c_char, Some(buf))
         };
-        // Call into dlsym; buffer lives until end of this function
         let sym = unsafe { libc::dlsym(self.handle, ptr) };
         if sym.is_null() {
             Err(DlError::Symbol(libc::last_error_ptr()))
@@ -138,12 +140,12 @@ impl Library {
         }
     }
 
-    /// Check if handle is null
+    /* Check if handle is null */
     pub fn is_null(&self) -> bool {
         self.handle.is_null()
     }
 
-    /// Consume and close the library explicitly
+    /* Consume and close the library explicitly */
     pub unsafe fn close(self) -> Result<(), DlError> {
         let h = self.handle;
         forget(self);
@@ -155,7 +157,7 @@ impl Library {
         }
     }
 
-    /// Leak the handle out (caller manages lifetime)
+    /* Leak the handle out (caller manages lifetime) */
     pub unsafe fn into_raw(self) -> *mut c_void {
         let h = self.handle;
         forget(self);
@@ -174,33 +176,36 @@ impl Drop for Library {
     }
 }
 
-/// RAII wrapper for a symbol tied to a `Library` lifetime.
-/// Stores the raw pointer and performs typed conversion at the use site.
+/* RAII wrapper for a symbol tied to a `Library` lifetime.
+ * Stores the raw pointer and performs typed conversion at the use site.
+ */
 pub struct Symbol<'lib, T> {
     raw: *mut c_void,
     _lib: PhantomData<&'lib Library>,
     _ty: PhantomData<T>,
 }
 
 impl<'lib, T> Symbol<'lib, T> {
-    /// Check if the underlying pointer is null
+    /* Check if the underlying pointer is null */
     pub fn is_null(&self) -> bool {
         self.raw.is_null()
     }
 
-    /// Get the raw pointer as `*mut c_void`
+    /* Get the raw pointer as `*mut c_void` */
     pub fn as_raw(&self) -> *mut c_void {
         self.raw
     }
 
-    /// Cast the raw pointer to a different pointer type
-    /// Safety: Caller must ensure `U` is the correct target type.
+    /* Cast the raw pointer to a different pointer type
+     * Safety: Caller must ensure `U` is the correct target type.
+     */
     pub unsafe fn as_ptr<U>(&self) -> *mut U {
         self.raw as *mut U
     }
 
-    /// Convert to the typed value (e.g., function pointer) at use site
-    /// Safety: `T` must be the correct type for the symbol.
+    /* Convert to the typed value (e.g., function pointer) at use site
+    Safety: `T` must be the correct type for the symbol.
+    */
     pub unsafe fn to_value(&self) -> T
     where
         T: Sized + Copy,
@@ -211,7 +216,6 @@ impl<'lib, T> Symbol<'lib, T> {
         core::ptr::read(src)
     }
 
-    /// Consume the wrapper and return the raw pointer
     pub fn into_raw(self) -> *mut c_void {
         let p = self.raw;
         forget(self);
@@ -222,13 +226,12 @@ impl<'lib, T> Symbol<'lib, T> {
 impl<'lib, T> Deref for Symbol<'lib, T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
-        // Reinterpret the `raw` pointer storage as a value of type `T`.
-        // This is safe if `T` is a pointer-sized function pointer or compatible pointer type.
+        /* Reinterpret the `raw` pointer storage as a value of type `T`. */
+        /* Safety: This is safe if `T` is a pointer-sized function pointer or compatible pointer type. */
         unsafe { &*((&self.raw as *const *mut c_void) as *const T) }
     }
 }
 
-/// Fetch last libc error C-string pointer (for printing)
 #[inline]
 pub fn last_error() -> *const c_char {
     libc::last_error_ptr()