refactor: 重命名 Node::from 方法为 Node::from_raw，简化节点创建逻辑并移除不必要的上下文引用

Author: ZR233

fdt-edit/src/fdt.rs

@@ -75,7 +75,7 @@ impl Fdt {
 
         for raw_node in raw_fdt.all_nodes() {
             let level = raw_node.level();
-            let node = Node::from(raw_node);
+            let node = Node::from_raw(raw_node);
 
             // 弹出栈直到达到正确的父级别
             // level 0 = 根节点，应该直接放入空栈

fdt-edit/src/lib.rs

@@ -15,7 +15,7 @@ pub use display::FmtLevel;
 pub use encode::{FdtData, FdtEncoder, NodeEncode};
 pub use fdt::{Fdt, MemoryReservation};
 pub use node::{
-    ClockRef, ClockType, FixedClock, MemoryRegion, Node, NodeChosen, NodeClock, NodeClockRef,
+    ClockRef, ClockType, FixedClock, MemoryRegion, Node, NodeChosen, NodeClock,
     NodeInterruptController, NodeMemory, NodeMut, NodeOp, NodePci, NodeRef, PciRange, PciSpace,
 };
 pub use prop::{Phandle, Property, RangesEntry, RawProperty, RegInfo, Status};

fdt-edit/src/node/chosen.rs

@@ -1,5 +1,7 @@
+use alloc::string::ToString;
+
 use super::{NodeOp, NodeTrait, RawNode};
-use crate::prop::PropertyKind;
+use crate::{Property, prop::PropertyKind};
 
 /// Chosen 节点，包含启动参数等信息
 #[derive(Clone, Debug)]
@@ -22,8 +24,8 @@ impl NodeTrait for NodeChosen {
 }
 
 impl NodeChosen {
-    pub fn new(name: &str) -> Self {
-        NodeChosen(RawNode::new(name))
+    pub fn new() -> Self {
+        NodeChosen(RawNode::new("chosen"))
     }
 
     /// 获取 bootargs 属性
@@ -41,6 +43,39 @@ impl NodeChosen {
         self.find_property_str("stdin-path")
     }
 
+    pub fn set_bootargs(&mut self, args: Option<&str>) {
+        if let Some(args) = args {
+            self.0.set_property(Property {
+                name: "bootargs".to_string(),
+                kind: PropertyKind::Str(args.to_string()),
+            });
+        } else {
+            self.0.remove_property("bootargs");
+        }
+    }
+
+    pub fn set_stdout_path(&mut self, path: Option<&str>) {
+        if let Some(path) = path {
+            self.0.set_property(Property {
+                name: "stdout-path".to_string(),
+                kind: PropertyKind::Str(path.to_string()),
+            });
+        } else {
+            self.0.remove_property("stdout-path");
+        }
+    }
+
+    pub fn set_stdin_path(&mut self, path: Option<&str>) {
+        if let Some(path) = path {
+            self.0.set_property(Property {
+                name: "stdin-path".to_string(),
+                kind: PropertyKind::Str(path.to_string()),
+            });
+        } else {
+            self.0.remove_property("stdin-path");
+        }
+    }
+
     /// 查找字符串属性
     fn find_property_str(&self, name: &str) -> Option<&str> {
         let prop = self.find_property(name)?;

fdt-edit/src/node/clock.rs

@@ -112,7 +112,7 @@ impl NodeClock {
     ///
     /// 通过查找每个 phandle 对应的 clock provider 的 #clock-cells，
     /// 正确解析 specifier 的长度。
-    pub fn clocks_with_context<'a>(&self, ctx: &FdtContext<'a>) -> Vec<ClockRef> {
+    pub fn clocks<'a>(&self, ctx: &FdtContext<'a>) -> Vec<ClockRef> {
         let Some(prop) = self.raw.find_property("clocks") else {
             return Vec::new();
         };
@@ -252,48 +252,3 @@ impl ClockRef {
         }
     }
 }
-
-/// 带上下文的 NodeClock 引用
-///
-/// 可以直接调用 `clocks()` 方法解析时钟引用
-pub struct NodeClockRef<'a> {
-    pub clock: &'a NodeClock,
-    pub ctx: &'a FdtContext<'a>,
-}
-
-impl<'a> NodeClockRef<'a> {
-    /// 创建新的带上下文的 NodeClock 引用
-    pub fn new(clock: &'a NodeClock, ctx: &'a FdtContext<'a>) -> Self {
-        Self { clock, ctx }
-    }
-
-    /// 解析 clocks 属性，返回时钟引用列表
-    pub fn clocks(&self) -> Vec<ClockRef> {
-        self.clock.clocks_with_context(self.ctx)
-    }
-
-    /// 获取 #clock-cells
-    pub fn clock_cells(&self) -> u32 {
-        self.clock.clock_cells
-    }
-
-    /// 获取时钟类型
-    pub fn kind(&self) -> &ClockType {
-        &self.clock.kind
-    }
-
-    /// 获取节点名称
-    pub fn name(&self) -> &str {
-        self.clock.name()
-    }
-
-    /// 获取时钟输出名称列表
-    pub fn clock_output_names(&self) -> &[String] {
-        &self.clock.clock_output_names
-    }
-
-    /// 获取时钟名称列表
-    pub fn clock_names(&self) -> &[String] {
-        &self.clock.clock_names
-    }
-}

fdt-edit/src/node/memory.rs

@@ -1,57 +1,36 @@
 use alloc::vec::Vec;
 
 use super::{NodeOp, NodeTrait, RawNode};
-use crate::prop::PropertyKind;
 pub use fdt_raw::MemoryRegion;
 
 /// Memory 节点，描述物理内存布局
 #[derive(Clone, Debug)]
-pub struct NodeMemory(pub(crate) RawNode);
+pub struct NodeMemory {
+    raw: RawNode,
+    pub regions: Vec<MemoryRegion>,
+}
 
 impl NodeOp for NodeMemory {}
 
 impl NodeTrait for NodeMemory {
     fn as_raw(&self) -> &RawNode {
-        &self.0
+        &self.raw
     }
 
     fn as_raw_mut(&mut self) -> &mut RawNode {
-        &mut self.0
+        &mut self.raw
     }
 
     fn to_raw(self) -> RawNode {
-        self.0
+        self.raw
     }
 }
 
 impl NodeMemory {
     pub fn new(name: &str) -> Self {
-        NodeMemory(RawNode::new(name))
-    }
-
-    /// 获取内存区域列表
-    ///
-    /// Memory 节点的 reg 属性描述了物理内存的布局
-    pub fn regions(&self) -> Vec<MemoryRegion> {
-        let Some(prop) = self.find_property("reg") else {
-            return Vec::new();
-        };
-
-        let PropertyKind::Reg(entries) = &prop.kind else {
-            return Vec::new();
-        };
-
-        entries
-            .iter()
-            .map(|entry| MemoryRegion {
-                address: entry.address,
-                size: entry.size.unwrap_or(0),
-            })
-            .collect()
-    }
-
-    /// 计算总内存大小
-    pub fn total_size(&self) -> u64 {
-        self.regions().iter().map(|r| r.size).sum()
+        NodeMemory {
+            raw: RawNode::new(name),
+            regions: Vec::new(),
+        }
     }
 }

fdt-edit/src/node/mod.rs

@@ -17,7 +17,7 @@ mod pci;
 mod r#ref;
 
 pub use chosen::NodeChosen;
-pub use clock::{ClockRef, ClockType, FixedClock, NodeClock, NodeClockRef};
+pub use clock::{ClockRef, ClockType, FixedClock, NodeClock};
 pub use interrupt_controller::{NodeInterruptController, is_interrupt_controller_node};
 pub use memory::{MemoryRegion, NodeMemory};
 pub use pci::*;
@@ -54,85 +54,64 @@ impl Node {
         Self::Raw(RawNode::new(""))
     }
 
-    fn new(raw: RawNode) -> Self {
-        let name = raw.name.as_str();
+    // fn new(raw: RawNode) -> Self {
+    //     let name = raw.name.as_str();
 
-        // 根据节点名称或属性判断类型
-        if name == "chosen" {
-            return Self::Chosen(NodeChosen(raw));
-        }
+    //     // 根据节点名称或属性判断类型
+    //     if name == "chosen" {
+    //         return Self::Chosen(NodeChosen(raw));
+    //     }
 
-        if name.starts_with("memory") {
-            return Self::Memory(NodeMemory(raw));
-        }
+    //     if name.starts_with("memory") {
+    //         return Self::Memory(NodeMemory(raw));
+    //     }
 
-        // 检查是否是中断控制器
-        if is_interrupt_controller_node(&raw) {
-            return Self::InterruptController(NodeInterruptController::new(raw));
-        }
+    //     // 检查是否是中断控制器
+    //     if is_interrupt_controller_node(&raw) {
+    //         return Self::InterruptController(NodeInterruptController::new(raw));
+    //     }
 
-        // 检查是否是时钟提供者
-        if raw.properties.iter().any(|p| p.name() == "#clock-cells") {
-            return Self::Clock(NodeClock::new(raw));
-        }
+    //     // 检查是否是时钟提供者
+    //     if raw.properties.iter().any(|p| p.name() == "#clock-cells") {
+    //         return Self::Clock(NodeClock::new(raw));
+    //     }
 
-        // 检查 device_type 属性
-        let mut node = Self::Raw(raw);
-        if let Some(t) = node.find_property("device_type")
-            && let PropertyKind::Str(dt) = &t.kind
-            && dt.as_str() == "pci"
-        {
-            node = Self::Pci(NodePci(node.to_raw()));
-        }
-        node
-    }
+    //     // 检查 device_type 属性
+    //     let mut node = Self::Raw(raw);
+    //     if let Some(t) = node.find_property("device_type")
+    //         && let PropertyKind::Str(dt) = &t.kind
+    //         && dt.as_str() == "pci"
+    //     {
+    //         node = Self::Pci(NodePci(node.to_raw()));
+    //     }
+    //     node
+    // }
 
     pub fn new_raw(name: &str) -> Self {
-        Self::new(RawNode::new(name))
+        Self::Raw(RawNode::new(name))
     }
 
-    /// 尝试转换为 Chosen 节点
-    pub fn as_chosen(&self) -> Option<&NodeChosen> {
-        if let Node::Chosen(c) = self {
-            Some(c)
-        } else {
-            None
-        }
-    }
+    pub fn from_raw<'a>(val: fdt_raw::Node<'a>) -> Self {
+        match val {
+            fdt_raw::Node::General(node_base) => {
 
-    /// 尝试转换为 Memory 节点
-    pub fn as_memory(&self) -> Option<&NodeMemory> {
-        if let Node::Memory(m) = self {
-            Some(m)
-        } else {
-            None
-        }
-    }
+                
 
-    /// 尝试转换为 Pci 节点
-    pub fn as_pci(&self) -> Option<&NodePci> {
-        if let Node::Pci(p) = self {
-            Some(p)
-        } else {
-            None
-        }
-    }
-
-    /// 尝试转换为 Clock 节点
-    pub fn as_clock(&self) -> Option<&NodeClock> {
-        if let Node::Clock(c) = self {
-            Some(c)
-        } else {
-            None
-        }
-    }
-
-    /// 尝试转换为 InterruptController 节点
-    pub fn as_interrupt_controller(&self) -> Option<&NodeInterruptController> {
-        if let Node::InterruptController(ic) = self {
-            Some(ic)
-        } else {
-            None
+                let raw_node = RawNode::from(node_base);
+                Self::Raw(raw_node)
+            }
+            fdt_raw::Node::Chosen(chosen) => {
+                let mut new_one = NodeChosen::new();
+                new_one.set_bootargs(chosen.bootargs());
+                new_one.set_stdout_path(chosen.stdout_path());
+                new_one.set_stdin_path(chosen.stdin_path());
+                Self::Chosen(new_one)
+            }
+            fdt_raw::Node::Memory(memory) => {
+                let mut raw_node = NodeMemory::new(memory.name());
+                raw_node.regions = memory.regions().collect();
+                Self::Memory(raw_node)
+            }
         }
     }
 }
@@ -543,33 +522,15 @@ impl RawNode {
     }
 }
 
-impl<'a> From<fdt_raw::Node<'a>> for Node {
-    fn from(raw_node: fdt_raw::Node<'a>) -> Self {
+impl<'a> From<fdt_raw::NodeBase<'a>> for RawNode {
+    fn from(raw_node: fdt_raw::NodeBase<'a>) -> Self {
         let mut node = RawNode::new(raw_node.name());
         // 转换属性
         for prop in raw_node.properties() {
-            // 特殊处理 reg 属性，需要 context 信息
-            if prop.name() == "reg"
-                && let Some(reg_iter) = raw_node.reg()
-            {
-                let entries = reg_iter
-                    .map(|e| super::prop::Reg {
-                        address: e.address,
-                        size: e.size,
-                    })
-                    .collect();
-                let prop = super::prop::Property {
-                    name: "reg".to_string(),
-                    kind: super::prop::PropertyKind::Reg(entries),
-                };
-                node.properties.push(prop);
-                continue;
-            }
-
             // 其他属性使用标准的 From 转换
             let raw = super::prop::Property::from(prop);
             node.properties.push(raw);
         }
-        Self::new(node)
+        node
     }
 }