wip: little refactors + add CPU topology nodes

Author: repnop

examples/tree_print.rs

@@ -1,20 +1,18 @@
-// use fdt::node::FdtNode;
+use fdt::helpers::UnalignedInfallibleNode;
 
-// static MY_FDT: &[u8] = include_bytes!("../dtb/test.dtb");
+static MY_FDT: &[u8] = include_bytes!("../dtb/test.dtb");
 
-// fn main() {
-//     let fdt = fdt::Fdt::new(MY_FDT).unwrap();
+fn main() {
+    let fdt = fdt::Fdt::new_unaligned(MY_FDT).unwrap();
 
-//     print_node(fdt.find_node("/").unwrap(), 0);
-// }
+    print_node(fdt.find_node("/").unwrap(), 0);
+}
 
-// fn print_node(node: FdtNode<'_, '_>, n_spaces: usize) {
-//     (0..n_spaces).for_each(|_| print!(" "));
-//     println!("{}/", node.name);
+fn print_node(node: UnalignedInfallibleNode<'_>, n_spaces: usize) {
+    (0..n_spaces).for_each(|_| print!(" "));
+    println!("{}/", node.name());
 
-//     for child in node.children() {
-//         print_node(child, n_spaces + 4);
-//     }
-// }
-
-fn main() {}
+    for child in node.children() {
+        print_node(child, n_spaces + 4);
+    }
+}

src/helpers.rs

@@ -0,0 +1,14 @@
+use crate::{
+    nodes::{root::Root, Node},
+    parsing::{aligned::AlignedParser, unaligned::UnalignedParser, NoPanic, Panic, ParserWithMode},
+};
+
+pub type FallibleParser<'a, P> = (<P as ParserWithMode<'a>>::Parser, NoPanic);
+pub type FallibleNode<'a, P> = Node<'a, FallibleParser<'a, P>>;
+pub type FallibleRoot<'a, P> = Root<'a, FallibleParser<'a, P>>;
+
+pub type AlignedFallibleNode<'a> = Node<'a, (AlignedParser<'a>, NoPanic)>;
+pub type UnalignedFallibleNode<'a> = Node<'a, (UnalignedParser<'a>, NoPanic)>;
+
+pub type AlignedInfallibleNode<'a> = Node<'a, (AlignedParser<'a>, Panic)>;
+pub type UnalignedInfallibleNode<'a> = Node<'a, (UnalignedParser<'a>, Panic)>;

src/lib.rs

@@ -62,15 +62,17 @@ extern crate std;
 mod tests;
 
 pub mod cell_collector;
+pub mod helpers;
 pub mod nodes;
 mod parsing;
 mod pretty_print;
 pub mod properties;
 mod util;
 
+use helpers::FallibleParser;
 use nodes::{
     root::{AllCompatibleIter, AllNodesIter, AllNodesWithNameIter, Root},
-    FallibleParser, Node,
+    Node,
 };
 use parsing::{
     aligned::AlignedParser, unaligned::UnalignedParser, NoPanic, Panic, ParseError, Parser, ParserWithMode,
@@ -93,11 +95,12 @@ pub enum FdtError {
     SliceTooSmall,
     /// An error was encountered during parsing
     ParseError(ParseError),
-    PHandleNotFound(u32),
+    MissingPHandleNode(u32),
     MissingParent,
     MissingRequiredNode(&'static str),
     MissingRequiredProperty(&'static str),
     InvalidPropertyValue,
+    InvalidNodeName,
     CollectCellsError,
 }
 
@@ -114,7 +117,7 @@ impl core::fmt::Display for FdtError {
             FdtError::BadPtr => write!(f, "an invalid pointer was passed"),
             FdtError::SliceTooSmall => write!(f, "provided slice is too small"),
             FdtError::ParseError(e) => core::fmt::Display::fmt(e, f),
-            FdtError::PHandleNotFound(value) => {
+            FdtError::MissingPHandleNode(value) => {
                 write!(f, "a node containing the `phandle` property value of `{value}` was not found")
             }
             FdtError::MissingParent => write!(f, "node parent is not present but needed to parse a property"),
@@ -125,6 +128,9 @@ impl core::fmt::Display for FdtError {
                 write!(f, "FDT node is missing a required property `{}`", name)
             }
             FdtError::InvalidPropertyValue => write!(f, "FDT property value is invalid"),
+            FdtError::InvalidNodeName => {
+                write!(f, "FDT node contained invalid characters or did not match the expected format")
+            }
             FdtError::CollectCellsError => {
                 write!(f, "overflow occurred while collecting `#<specifier>-cells` size values into the desired type")
             }

src/nodes.rs

@@ -5,6 +5,7 @@ pub mod memory;
 pub mod root;
 
 use crate::{
+    helpers::FallibleNode,
     parsing::{
         aligned::AlignedParser, BigEndianToken, NoPanic, Panic, PanicMode, ParseError, Parser, ParserWithMode,
         StringsBlock, StructsBlock,
@@ -95,10 +96,6 @@ impl core::fmt::Display for NodeName<'_> {
     }
 }
 
-pub type FallibleParser<'a, P> = (<P as ParserWithMode<'a>>::Parser, NoPanic);
-pub type FallibleNode<'a, P> = Node<'a, FallibleParser<'a, P>>;
-pub type FallibleRoot<'a, P> = Root<'a, FallibleParser<'a, P>>;
-
 /// A generic devicetree node.
 pub struct Node<'a, P: ParserWithMode<'a>> {
     pub(crate) this: &'a RawNode<<P as Parser<'a>>::Granularity>,

src/nodes/aliases.rs

@@ -1,5 +1,8 @@
-use super::{AsNode, FallibleNode, FallibleParser, Node, NodePropertiesIter};
-use crate::parsing::{NoPanic, ParserWithMode};
+use super::{AsNode, Node, NodePropertiesIter};
+use crate::{
+    helpers::{FallibleNode, FallibleParser},
+    parsing::{NoPanic, ParserWithMode},
+};
 
 /// [Devicetree 3.3. `/aliases`
 /// node](https://devicetree-specification.readthedocs.io/en/latest/chapter3-devicenodes.html#aliases-node)

src/nodes/chosen.rs

@@ -2,8 +2,9 @@
 // v. 2.0. If a copy of the MPL was not distributed with this file, You can
 // obtain one at https://mozilla.org/MPL/2.0/.
 
-use super::{FallibleNode, FallibleParser, FallibleRoot, Node};
+use super::{FallibleNode, Node};
 use crate::{
+    helpers::{FallibleParser, FallibleRoot},
     parsing::{aligned::AlignedParser, Panic, ParseError, ParserWithMode},
     FdtError,
 };