Merge pull request #118 from stm32-rs/errors

improve derive for registers (breaking)

Author: burrbull

src/patch/device.rs

@@ -1,38 +1,23 @@
 use anyhow::{anyhow, Context};
 use svd_parser::svd::{Device, Peripheral, PeripheralInfo};
-use yaml_rust::yaml::Hash;
+use yaml_rust::{yaml::Hash, Yaml};
 
+use std::collections::HashSet;
 use std::{fs::File, io::Read, path::Path};
 
+use super::iterators::{MatchIter, Matched};
 use super::modify_register_properties;
 use super::peripheral::PeripheralExt;
 use super::yaml_ext::{AsType, GetVal};
 use super::{abspath, matchname, PatchResult, VAL_LVL};
 use super::{make_address_block, make_address_blocks, make_cpu, make_interrupt, make_peripheral};
 
-pub struct PerIter<'a, 'b> {
-    it: std::slice::IterMut<'a, Peripheral>,
-    spec: &'b str,
-    check_derived: bool,
-}
-
-impl<'a, 'b> Iterator for PerIter<'a, 'b> {
-    type Item = &'a mut Peripheral;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.it.by_ref().find(|next| {
-            matchname(&next.name, self.spec) && !(self.check_derived && next.derived_from.is_some())
-        })
-    }
-}
+pub type PerMatchIterMut<'a, 'b> = MatchIter<'b, std::slice::IterMut<'a, Peripheral>>;
 
 /// Collecting methods for processing device contents
 pub trait DeviceExt {
     /// Iterates over all peripherals that match pspec
-    fn iter_peripherals<'a, 'b>(
-        &'a mut self,
-        spec: &'b str,
-        check_derived: bool,
-    ) -> PerIter<'a, 'b>;
+    fn iter_peripherals<'a, 'b>(&'a mut self, spec: &'b str) -> PerMatchIterMut<'a, 'b>;
 
     /// Work through a device, handling all peripherals
     fn process(&mut self, device: &Hash, update_fields: bool) -> PatchResult;
@@ -54,7 +39,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
@@ -73,17 +58,8 @@ pub trait DeviceExt {
 }
 
 impl DeviceExt for Device {
-    fn iter_peripherals<'a, 'b>(
-        &'a mut self,
-        spec: &'b str,
-        check_derived: bool,
-    ) -> PerIter<'a, 'b> {
-        // check_derived=True
-        PerIter {
-            spec,
-            check_derived,
-            it: self.peripherals.iter_mut(),
-        }
+    fn iter_peripherals<'a, 'b>(&'a mut self, spec: &'b str) -> PerMatchIterMut<'a, 'b> {
+        self.peripherals.iter_mut().matched(spec)
     }
 
     fn process(&mut self, device: &Hash, update_fields: bool) -> PatchResult {
@@ -163,9 +139,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
@@ -246,7 +221,10 @@ impl DeviceExt for Device {
     }
 
     fn modify_peripheral(&mut self, pspec: &str, pmod: &Hash) -> PatchResult {
-        for ptag in self.iter_peripherals(pspec, true) {
+        let mut modified = HashSet::new();
+        for ptag in self.iter_peripherals(pspec) {
+            modified.insert(ptag.name.clone());
+
             ptag.modify_from(make_peripheral(pmod, true)?, VAL_LVL)?;
             if let Some(ints) = pmod.get_hash("interrupts")? {
                 for (iname, val) in ints {
@@ -271,6 +249,17 @@ impl DeviceExt for Device {
                 ptag.address_block = Some(make_address_blocks(abmod)?);
             }
         }
+        // If this peripheral has derivations, update the derived
+        // peripherals to reference the new name.
+        if let Some(value) = pmod.get_str("name")? {
+            for p in self.peripherals.iter_mut() {
+                if let Some(old_name) = p.derived_from.as_mut() {
+                    if modified.contains(old_name) {
+                        *old_name = value.into();
+                    }
+                }
+            }
+        }
         Ok(())
     }
 
@@ -288,15 +277,40 @@ impl DeviceExt for Device {
         Ok(())
     }
 
-    fn derive_peripheral(&mut self, pname: &str, pderive: &str) -> PatchResult {
-        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(
+    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())),
-                VAL_LVL,
-            )?;
+            )
+        } 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));
+        };
+
+        if !pderive.contains('.') {
+            self.get_peripheral(pderive)
+                .ok_or_else(|| anyhow!("peripheral {} not found", pderive))?;
+        }
+
+        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()
@@ -343,7 +357,10 @@ impl DeviceExt for Device {
     }
 
     fn clear_fields(&mut self, pspec: &str) -> PatchResult {
-        for ptag in self.iter_peripherals(pspec, false) {
+        for ptag in self.iter_peripherals(pspec) {
+            if ptag.derived_from.is_some() {
+                continue;
+            }
             ptag.clear_fields("*")?;
         }
         Ok(())
@@ -357,7 +374,7 @@ impl DeviceExt for Device {
     ) -> PatchResult {
         // Find all peripherals that match the spec
         let mut pcount = 0;
-        for ptag in self.iter_peripherals(pspec, false) {
+        for ptag in self.iter_peripherals(pspec) {
             pcount += 1;
             ptag.process(peripheral, update_fields)
                 .with_context(|| format!("Processing peripheral `{}`", ptag.name))?;

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,48 @@ 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!(
@@ -668,6 +724,9 @@ impl PeripheralExt for Peripheral {
 
     fn clear_fields(&mut self, rspec: &str) -> PatchResult {
         for rtag in self.iter_registers(rspec) {
+            if rtag.derived_from.is_some() {
+                continue;
+            }
             rtag.clear_field("*")?;
         }
         Ok(())

src/patch/register.rs

@@ -90,6 +90,9 @@ pub trait RegisterExt {
 
 impl RegisterExt for Register {
     fn process(&mut self, rmod: &Hash, pname: &str, update_fields: bool) -> PatchResult {
+        if self.derived_from.is_some() {
+            return Ok(());
+        }
         // Handle deletions
         for fspec in rmod.str_vec_iter("_delete") {
             self.delete_field(fspec)
@@ -272,6 +275,9 @@ impl RegisterExt for Register {
 
     fn clear_field(&mut self, fspec: &str) -> PatchResult {
         for ftag in self.iter_fields(fspec) {
+            if ftag.derived_from.is_some() {
+                continue;
+            }
             ftag.enumerated_values = Vec::new();
             ftag.write_constraint = None;
         }