_derive register (Rust)

Author: burrbull

src/patch/device.rs

@@ -1,6 +1,6 @@
 use anyhow::{anyhow, Context};
 use svd_parser::svd::{Device, Peripheral, PeripheralInfo};
-use yaml_rust::yaml::Hash;
+use yaml_rust::{yaml::Hash, Yaml};
 
 use std::{fs::File, io::Read, path::Path};
 
@@ -54,7 +54,7 @@ pub trait DeviceExt {
 
     /// Remove registers from pname and mark it as derivedFrom pderive.
     /// Update all derivedFrom referencing pname
-    fn derive_peripheral(&mut self, pname: &str, pderive: &str) -> PatchResult;
+    fn derive_peripheral(&mut self, pname: &str, pderive: &Yaml) -> PatchResult;
 
     /// Move registers from pold to pnew.
     /// Update all derivedFrom referencing pold
@@ -163,9 +163,8 @@ impl DeviceExt for Device {
         // Handle any derived peripherals
         for (pname, pderive) in device.hash_iter("_derive") {
             let pname = pname.str()?;
-            let pderive = pderive.str()?;
             self.derive_peripheral(pname, pderive)
-                .with_context(|| format!("Deriving peripheral `{}` from `{}`", pname, pderive))?;
+                .with_context(|| format!("Deriving peripheral `{}` from `{:?}`", pname, pderive))?;
         }
 
         // Handle any rebased peripherals
@@ -288,15 +287,37 @@ impl DeviceExt for Device {
         Ok(())
     }
 
-    fn derive_peripheral(&mut self, pname: &str, pderive: &str) -> PatchResult {
+    fn derive_peripheral(&mut self, pname: &str, pderive: &Yaml) -> PatchResult {
+        let (pderive, info) = if let Some(pderive) = pderive.as_str() {
+            (
+                pderive,
+                PeripheralInfo::builder().derived_from(Some(pderive.into())),
+            )
+        } else if let Some(hash) = pderive.as_hash() {
+            let pderive = hash.get_str("_from")?.ok_or_else(|| {
+                anyhow!(
+                    "derive: source peripheral not given, please add a _from field to {}",
+                    pname
+                )
+            })?;
+            (
+                pderive,
+                make_peripheral(hash, true)?.derived_from(Some(pderive.into())),
+            )
+        } else {
+            return Err(anyhow!("derive: incorrect syntax for {}", pname));
+        };
         self.get_peripheral(pderive)
             .ok_or_else(|| anyhow!("peripheral {} not found", pderive))?;
-        self.get_mut_peripheral(pname)
-            .ok_or_else(|| anyhow!("peripheral {} not found", pname))?
-            .modify_from(
-                PeripheralInfo::builder().derived_from(Some(pderive.into())),
-                VAL_LVL,
-            )?;
+
+        match self.get_mut_peripheral(pname) {
+            Some(peripheral) => peripheral.modify_from(info, VAL_LVL)?,
+            None => {
+                let peripheral = info.name(pname.into()).build(VAL_LVL)?.single();
+                self.peripherals.push(peripheral);
+            }
+        }
+
         for p in self
             .peripherals
             .iter_mut()

src/patch/peripheral.rs

@@ -46,6 +46,10 @@ pub trait PeripheralExt {
     /// Add rname given by radd to ptag
     fn add_register(&mut self, rname: &str, radd: &Hash) -> PatchResult;
 
+    /// Remove fields from rname and mark it as derivedFrom rderive.
+    /// Update all derivedFrom referencing rname
+    fn derive_register(&mut self, rname: &str, rderive: &Yaml) -> PatchResult;
+
     /// Add rname given by deriving from rsource to ptag
     fn copy_register(&mut self, rname: &str, rderive: &Hash) -> PatchResult;
 
@@ -158,6 +162,14 @@ impl PeripheralExt for Peripheral {
             }
         }
 
+        // Handle any copied peripherals
+        for (rname, rderive) in pmod.hash_iter("_copy") {
+            let rderive = rderive.hash()?;
+            let rname = rname.str()?;
+            self.copy_register(rname, rderive)
+                .with_context(|| format!("Copying register `{}`", rname))?
+        }
+
         // Handle modifications
         for (rspec, rmod) in pmod.hash_iter("_modify") {
             let rmod = rmod.hash()?;
@@ -237,25 +249,27 @@ impl PeripheralExt for Peripheral {
         }
 
         for (rname, rderive) in pmod.hash_iter("_derive") {
-            let rderive = rderive.hash()?;
             let rname = rname.str()?;
             match rname {
                 "_registers" => {
-                    for (rname, val) in rderive {
+                    for (rname, val) in rderive.hash()? {
                         let rname = rname.str()?;
-                        self.copy_register(rname, val.hash()?)
-                            .with_context(|| format!("Copying register `{}`", rname))?;
+                        self.derive_register(rname, val).with_context(|| {
+                            format!("Deriving register `{}` from `{:?}`", rname, val)
+                        })?;
                     }
                 }
-                "_interrupts" => {
+                "_clusters" => {
                     return Err(anyhow!(
-                        "deriving interrupts not implemented yet: {}",
+                        "deriving clusters is not implemented yet: {}",
                         rname
                     ))
                 }
-                _ => self
-                    .copy_register(rname, rderive)
-                    .with_context(|| format!("Copying register `{}`", rname))?,
+                _ => {
+                    self.derive_register(rname, rderive).with_context(|| {
+                        format!("Deriving register `{}` from `{:?}`", rname, rderive)
+                    })?;
+                }
             }
         }
 
@@ -343,6 +357,47 @@ impl PeripheralExt for Peripheral {
         Ok(())
     }
 
+    fn derive_register(&mut self, rname: &str, rderive: &Yaml) -> PatchResult {
+        let (rderive, info) = if let Some(rderive) = rderive.as_str() {
+            (
+                rderive,
+                RegisterInfo::builder().derived_from(Some(rderive.into())),
+            )
+        } else if let Some(hash) = rderive.as_hash() {
+            let rderive = hash.get_str("_from")?.ok_or_else(|| {
+                anyhow!(
+                    "derive: source register not given, please add a _from field to {}",
+                    rname
+                )
+            })?;
+            (
+                rderive,
+                make_register(hash)?.derived_from(Some(rderive.into())),
+            )
+        } else {
+            return Err(anyhow!("derive: incorrect syntax for {}", rname));
+        };
+        self.get_register(rderive)
+            .ok_or_else(|| anyhow!("register {} not found", rderive))?;
+
+        match self.get_mut_register(rname) {
+            Some(register) => register.modify_from(info, VAL_LVL)?,
+            None => {
+                let register = info.name(rname.into()).build(VAL_LVL)?.single();
+                self.registers
+                    .get_or_insert_with(Default::default)
+                    .push(RegisterCluster::Register(register));
+            }
+        }
+        for r in self
+            .registers_mut()
+            .filter(|r| r.derived_from.as_deref() == Some(rname))
+        {
+            r.derived_from = Some(rderive.into());
+        }
+        Ok(())
+    }
+
     fn copy_register(&mut self, rname: &str, rderive: &Hash) -> PatchResult {
         let srcname = rderive.get_str("_from")?.ok_or_else(|| {
             anyhow!(