fix: can not add a new node / prop

refactor: serialize and patch

To avoid copy-paste word, we use SerializeMap instead of
`serialize_newtype_struct`. This change required rewrite
`serialize_dynamic_field` function and split it, so we can not use
backtracking. Now it will create a new serailizer for every node or
prop.

Signed-off-by: Woshiluo Luo <[email protected]>

Author: woshiluo

examples/re_encode.rs

@@ -1,3 +1,4 @@
+use serde_device_tree::ser::{patch::Patch, serializer::ValueType};
 use serde_device_tree::{Dtb, DtbPtr, buildin::Node, error::Error, from_raw_mut};
 
 use std::io::prelude::*;
@@ -21,7 +22,8 @@ fn main() -> Result<(), Error> {
     let dtb = Dtb::from(ptr).share();
 
     let root: Node = from_raw_mut(&dtb).unwrap();
-    serde_device_tree::ser::to_dtb(&root, &[], &mut buf).unwrap();
+    let patch: Patch = Patch::new("/chosen/a", &"1", ValueType::Prop);
+    serde_device_tree::ser::to_dtb(&root, &[patch], &mut buf).unwrap();
 
     let mut file = std::fs::File::create("gen.dtb").unwrap();
     file.write_all(&buf).unwrap();

examples/serialize.rs

@@ -1,6 +1,8 @@
 use serde::Serialize;
 use std::io::prelude::*;
 
+use serde_device_tree::ser::serializer::ValueType;
+
 const MAX_SIZE: usize = 256 + 32;
 
 fn main() {
@@ -19,7 +21,8 @@ fn main() {
 
     {
         let new_base = Base1 { hello: "added" };
-        let patch = serde_device_tree::ser::patch::Patch::new("/base3", &new_base as _);
+        let patch =
+            serde_device_tree::ser::patch::Patch::new("/base3", &new_base as _, ValueType::Node);
         let list = [patch];
         let base = Base {
             hello: 0xdeedbeef,

src/de_mut/node.rs

@@ -57,8 +57,8 @@ impl<'de> Node<'de> {
         let result = match self.cursor.clone().move_on(self.dtb) {
             Cursor::Title(c) => {
                 let (name, _) = c.split_on(self.dtb);
-                let take_result = c.take_node_on(self.dtb, name);
-                take_result
+
+                c.take_node_on(self.dtb, name)
             }
             _ => unreachable!("Node's cursor should on its start"),
         };
@@ -333,7 +333,15 @@ impl Serialize for Node<'_> {
     where
         S: serde::Serializer,
     {
-        serializer.serialize_newtype_struct(crate::de_mut::NODE_NAME, self)
+        use serde::ser::SerializeMap;
+        let mut map = serializer.serialize_map(None)?;
+        for prop in self.props() {
+            map.serialize_entry(prop.get_name(), &prop)?;
+        }
+        for node in self.nodes() {
+            map.serialize_entry(node.get_full_name(), &node.deserialize::<Node>())?;
+        }
+        map.end()
     }
 }
 

src/ser/mod.rs

@@ -25,8 +25,9 @@ where
         let mut patch_list = crate::ser::patch::PatchList::new(list);
         let mut block = crate::ser::string_block::StringBlock::new(writer, &mut offset);
         let mut ser =
-            crate::ser::serializer::Serializer::new(&mut dst, &mut block, &mut patch_list);
-        data.serialize(&mut ser)?;
+            crate::ser::serializer::SerializerInner::new(&mut dst, &mut block, &mut patch_list);
+        let ser = crate::ser::serializer::Serializer::new(&mut ser);
+        data.serialize(ser)?;
     };
     list.iter().for_each(|patch| patch.init());
     // Write from bottom to top, to avoid overlap.
@@ -44,11 +45,11 @@ where
         let mut block = crate::ser::string_block::StringBlock::new(string_block, &mut offset);
         let mut dst = crate::ser::pointer::Pointer::new(Some(data_block));
         let mut ser =
-            crate::ser::serializer::Serializer::new(&mut dst, &mut block, &mut patch_list);
-        data.serialize(&mut ser)?;
-        ser.dst.step_by_u32(FDT_END);
-        ser.dst.get_offset()
-    };
+            crate::ser::serializer::SerializerInner::new(&mut dst, &mut block, &mut patch_list);
+        let ser = crate::ser::serializer::Serializer::new(&mut ser);
+        data.serialize(ser)?
+    }
+    .1;
     // Make header
     {
         let header = unsafe { &mut *(header.as_mut_ptr() as *mut Header) };

src/ser/patch.rs

@@ -1,33 +1,51 @@
 use super::serializer::Serializer;
+use super::serializer::ValueType;
 use core::cell::Cell;
 
 /// Since this crate is mostly work with `noalloc`, we use `Patch` and `PatchList` for change or
 /// add on a dtb.
 pub struct Patch<'se> {
-    pub data: &'se dyn dyn_serde::Serialize,
     name: &'se str,
+    pub data: &'se dyn dyn_serde::Serialize,
+    pub patch_type: ValueType,
 
     /// This patch match how many item between its path and serializer.
     matched_depth: Cell<usize>,
     /// Show this patch have been parsed.
     parsed: Cell<bool>,
 }
 
+impl core::fmt::Debug for Patch<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("")
+            .field("name", &self.name)
+            .field("patch_type", &self.patch_type)
+            .field("matched_depth", &self.matched_depth)
+            .field("parsed", &self.parsed)
+            .finish()
+    }
+}
+
 impl<'se> Patch<'se> {
     #[inline(always)]
-    pub fn new(name: &'se str, data: &'se dyn dyn_serde::Serialize) -> Patch<'se> {
+    pub fn new(
+        name: &'se str,
+        data: &'se dyn dyn_serde::Serialize,
+        patch_type: ValueType,
+    ) -> Patch<'se> {
         Patch {
             name,
             data,
-            matched_depth: Cell::new(0),
+            patch_type,
+            matched_depth: Cell::new(1),
             parsed: Cell::new(false),
         }
     }
 
     #[inline(always)]
     /// Reset the status of patch.
     pub fn init(&self) {
-        self.matched_depth.set(0);
+        self.matched_depth.set(1);
         self.parsed.set(false);
     }
 
@@ -38,17 +56,14 @@ impl<'se> Patch<'se> {
 
     #[inline(always)]
     pub fn get_depth_path(&self, x: usize) -> &'se str {
-        if x == 0 {
-            return "";
-        }
-        self.name.split('/').nth(x).unwrap_or_default()
+        self.name.split('/').nth(x - 1).unwrap_or_default()
     }
 
     // I hope to impl serde::ser::Serializer, but erase_serialize's return value is different from
     // normal serialize, so we do this.
     /// Serialize this patch with serializer.
     #[inline(always)]
-    pub fn serialize(&self, serializer: &mut Serializer<'se>) {
+    pub fn serialize(&self, serializer: Serializer<'_, 'se>) {
         self.parsed.set(true);
         self.data
             .serialize_dyn(&mut <dyn dyn_serde::Serializer>::new(serializer))
@@ -57,18 +72,20 @@ impl<'se> Patch<'se> {
 }
 
 /// Here is a list of `Patch`, and have some methods for update `Patch` status.
+#[derive(Debug)]
 pub struct PatchList<'se> {
     list: &'se [Patch<'se>],
 }
 
 impl<'se> PatchList<'se> {
     #[inline(always)]
     pub fn new(list: &'se [Patch<'se>]) -> PatchList<'se> {
+        list.iter().for_each(|x| x.init());
         PatchList { list }
     }
 
     #[inline(always)]
-    pub fn step_forward(&self, name: &'se str, depth: usize) -> Option<&'se Patch<'se>> {
+    pub fn step_forward(&self, name: &str, depth: usize) -> Option<&'se Patch<'se>> {
         let mut matched_patch = None;
         self.list.iter().for_each(|patch| {
             if patch.matched_depth.get() == depth - 1 && patch.get_depth_path(depth) == name {

src/ser/pointer.rs

@@ -31,10 +31,12 @@ impl<'se> Pointer<'se> {
         }
     }
 
+    /// Create a PROP header with nop padding, return the offset of `FDT_PROP` token.
     #[inline(always)]
     pub fn step_by_prop(&mut self) -> usize {
         self.step_by_u32(FDT_PROP);
         let offset = self.offset;
+        // Put 2 nop as `name` and `nameoff`.
         self.step_by_u32(FDT_NOP); // When create prop header, we do not know how long of the prop value.
         self.step_by_u32(FDT_NOP); // We can not assume this is a prop, so nop for default.
         offset