value: describe 'compatible' in null separated Compatible structure

Signed-off-by: Zhouqi Jiang <luojia@hust.edu.cn>

Author: luojia65

examples/hifive-unmatched-a00.rs

@@ -2,6 +2,7 @@ extern crate alloc;
 
 use alloc::collections::BTreeMap;
 use serde_derive::Deserialize;
+use serde_device_tree::Compatible;
 
 static DEVICE_TREE: &'static [u8] = include_bytes!("hifive-unmatched-a00.dtb");
 
@@ -12,7 +13,7 @@ struct Tree<'a> {
     #[serde(rename = "#size-cells")]
     num_size_cells: u32,
     model: &'a str,
-    compatible: &'a str,
+    compatible: Compatible<'a>,
     chosen: Option<Chosen<'a>>,
     cpus: Cpus<'a>,
 }
@@ -43,7 +44,8 @@ enum MaybeCpu<'a> {
 
 #[derive(Debug, Deserialize)]
 struct Cpu<'a> {
-    compatible: &'a str,
+    #[serde(borrow)]
+    compatible: Compatible<'a>,
 }
 
 fn main() {
@@ -52,7 +54,7 @@ fn main() {
     println!("#address_cells = {}", t.num_address_cells);
     println!("#size_cells = {}", t.num_size_cells);
     println!("model = {}", t.model);
-    println!("compatible = {}", t.compatible);
+    println!("compatible = {:?}", t.compatible);
     if let Some(chosen) = t.chosen {
         if let Some(stdout_path) = chosen.stdout_path {
             println!("stdout = {}", stdout_path);
@@ -64,7 +66,7 @@ fn main() {
     println!("cpu u_boot_dm_spl = {}", t.cpus.u_boot_dm_spl);
     for (cpu_name, cpu) in t.cpus.cpu {
         if let MaybeCpu::Cpu(cpu) = cpu {
-            println!("cpu {}, compaible = {}", cpu_name, cpu.compatible)
+            println!("cpu {}, compaible = {:?}", cpu_name, cpu.compatible)
         }
     }
 }

examples/qemu-virt.rs

@@ -1,4 +1,4 @@
-//! 这是一个 `from_raw_mut` 反序列化设备树的示例。不需要 `alloc`。
+//! 这是一个 `from_raw_mut` 反序列化设备树的示例。不需要 `alloc`。
 // extern crate alloc;
 
 // 在实际使用中，将这里的 `serde_derive::Deserialize` 改为 `serde::Deserialize`。
@@ -12,7 +12,8 @@ use serde_derive::Deserialize;
 // - `StrSeq`: '\0' 分隔的一组字符串，设备树中一种常见的属性类型，这个类型要求可变的内存。
 use serde_device_tree::{
     buildin::{NodeSeq, Reg, StrSeq},
-    from_raw_mut, Dtb, DtbPtr, error::Error,
+    error::Error,
+    from_raw_mut, Dtb, DtbPtr,
 };
 
 fn main() -> Result<(), Error> {

src/lib.rs

@@ -23,6 +23,9 @@ pub mod error;
 
 mod common;
 mod de_mut;
+mod value;
+
+pub use value::compatible::Compatible;
 
 #[doc(inline)]
 pub use de::from_raw;

src/value/compatible.rs

@@ -0,0 +1,75 @@
+use core::{fmt, marker::PhantomData};
+use serde::{de::Visitor, Deserialize};
+
+/// Field representing compatability of a certain device in the tree.
+///
+/// This structure is represented in a list of string that is separated with Unicode `NUL` character.
+pub struct Compatible<'a> {
+    data: &'a [u8],
+}
+
+impl<'a> Compatible<'a> {
+    pub fn iter(&self) -> Iter<'a> {
+        Iter {
+            remaining: self.data,
+        }
+    }
+}
+
+impl<'de: 'a, 'a> Deserialize<'de> for Compatible<'a> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        struct StrListVisitor<'de, 'a>(PhantomData<&'de ()>, PhantomData<Compatible<'a>>);
+        impl<'de: 'a, 'a> Visitor<'de> for StrListVisitor<'de, 'a> {
+            type Value = Compatible<'a>;
+
+            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> std::fmt::Result {
+                write!(formatter, "string list")
+            }
+
+            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
+            where
+                E: serde::de::Error,
+            {
+                // TODO utf-8 check
+                Ok(Compatible { data: v })
+            }
+        }
+        deserializer.deserialize_bytes(StrListVisitor(PhantomData, PhantomData))
+    }
+}
+
+impl fmt::Debug for Compatible<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.iter()).finish()
+    }
+}
+
+pub struct Iter<'a> {
+    remaining: &'a [u8],
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.remaining.len() == 0 {
+            return None;
+        }
+        let mut idx = 0;
+        while let Some(byte) = self.remaining.get(idx) {
+            if byte == &b'\0' {
+                break;
+            }
+            idx += 1;
+        }
+        let (ans, rest) = self.remaining.split_at(idx);
+        if let [0, ..] = rest {
+            // skip '\0'
+            self.remaining = &rest[1..];
+        }
+        Some(core::str::from_utf8(ans).unwrap())
+    }
+}

src/value/mod.rs

@@ -0,0 +1,2 @@
+pub mod compatible;
+mod tree;

src/value/tree.rs

@@ -0,0 +1 @@
+// TODO reference to a device tree