Support finding nodes by name without address.

Many device tree nodes have names containing both a node-name and a
unit-address component, like memory@40000000. It should be possible
to find them by just the node-name.

Author: qwandor

src/fdt/mod.rs

@@ -403,10 +403,15 @@ impl<'a> Fdt<'a> {
             return Some(Ok(current_node));
         }
         for component in path.split('/').filter(|s| !s.is_empty()) {
+            let include_address = component.contains('@');
             match current_node.children().find(|child| {
-                child
-                    .as_ref()
-                    .is_ok_and(|c| c.name().is_ok_and(|n| n == component))
+                child.as_ref().is_ok_and(|c| {
+                    if include_address {
+                        c.name().is_ok_and(|n| n == component)
+                    } else {
+                        c.name_without_address().is_ok_and(|n| n == component)
+                    }
+                })
             }) {
                 Some(Ok(node)) => current_node = node,
                 Some(Err(e)) => return Some(Err(e)),

src/fdt/node.rs

@@ -24,8 +24,6 @@ pub struct FdtNode<'a> {
 impl<'a> FdtNode<'a> {
     /// Returns the name of this node.
     ///
-    /// # Examples
-    ///
     /// # Errors
     ///
     /// Returns an
@@ -49,6 +47,24 @@ impl<'a> FdtNode<'a> {
         self.fdt.string_at_offset(name_offset, None)
     }
 
+    /// Returns the name of this node without the unit address, if any.
+    ///
+    /// # Errors
+    ///
+    /// Returns an
+    /// [`FdtErrorKind::InvalidOffset`](crate::error::FdtErrorKind::InvalidOffset)
+    /// if the name offset is invalid or an
+    /// [`FdtErrorKind::InvalidString`](crate::error::FdtErrorKind::InvalidString) if the string at the offset is not null-terminated
+    /// or contains invalid UTF-8.
+    pub fn name_without_address(&self) -> Result<&'a str, FdtError> {
+        let name = self.name()?;
+        if let Some((name, _)) = name.split_once('@') {
+            Ok(name)
+        } else {
+            Ok(name)
+        }
+    }
+
     /// Returns a property by its name.
     ///
     /// # Performance
@@ -126,9 +142,14 @@ impl<'a> FdtNode<'a> {
     /// assert_eq!(child.name().unwrap(), "child1");
     /// ```
     pub fn child(&self, name: &str) -> Result<Option<FdtNode<'a>>, FdtError> {
+        let include_address = name.contains('@');
         for child in self.children() {
             let child = child?;
-            if child.name()? == name {
+            if if include_address {
+                child.name()? == name
+            } else {
+                child.name_without_address()? == name
+            } {
                 return Ok(Some(child));
             }
         }
@@ -146,7 +167,7 @@ impl<'a> FdtNode<'a> {
     /// let root = fdt.root().unwrap();
     /// let mut children = root.children();
     /// assert_eq!(children.next().unwrap().unwrap().name().unwrap(), "child1");
-    /// assert_eq!(children.next().unwrap().unwrap().name().unwrap(), "child2");
+    /// assert_eq!(children.next().unwrap().unwrap().name().unwrap(), "child2@42");
     /// assert!(children.next().is_none());
     /// ```
     pub fn children(&self) -> impl Iterator<Item = Result<FdtNode<'a>, FdtError>> + use<'a> {

tests/dtb/test_children.dtb

@@ -1,11 +1,14 @@
 /dts-v1/;
 
 / {
+    #address-cells = <0x01>;
+    #size-cells = <0x00>;
+
     child1 {
         prop1 = <0x12345678>;
     };
 
-    child2 {
-        prop2 = "hello";
+    child2@42 {
+        reg = <0x00>;
     };
 };

tests/dts/test_children.dts

@@ -17,9 +17,11 @@ fn read_child_nodes() {
 
     let child1 = children.next().unwrap().unwrap();
     assert_eq!(child1.name().unwrap(), "child1");
+    assert_eq!(child1.name_without_address().unwrap(), "child1");
 
-    let child2 = children.next().unwrap().unwrap();
-    assert_eq!(child2.name().unwrap(), "child2");
+    let child3 = children.next().unwrap().unwrap();
+    assert_eq!(child3.name().unwrap(), "child2@42");
+    assert_eq!(child3.name_without_address().unwrap(), "child2");
 
     assert!(children.next().is_none());
 }
@@ -86,7 +88,10 @@ fn get_child_by_name() {
     assert_eq!(child1.name().unwrap(), "child1");
 
     let child2 = root.child("child2").unwrap().unwrap();
-    assert_eq!(child2.name().unwrap(), "child2");
+    assert_eq!(child2.name().unwrap(), "child2@42");
+
+    let child2_with_address = root.child("child2@42").unwrap().unwrap();
+    assert_eq!(child2_with_address.name().unwrap(), "child2@42");
 
     assert!(root.child("non-existent-child").unwrap().is_none());
 }