skip derived

Author: burrbull

src/patch/device.rs

@@ -4,35 +4,19 @@ use yaml_rust::{yaml::Hash, Yaml};
 
 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;
@@ -73,17 +57,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 {
@@ -245,7 +220,7 @@ impl DeviceExt for Device {
     }
 
     fn modify_peripheral(&mut self, pspec: &str, pmod: &Hash) -> PatchResult {
-        for ptag in self.iter_peripherals(pspec, true) {
+        for ptag in self.iter_peripherals(pspec) {
             ptag.modify_from(make_peripheral(pmod, true)?, VAL_LVL)?;
             if let Some(ints) = pmod.get_hash("interrupts")? {
                 for (iname, val) in ints {
@@ -364,7 +339,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(())
@@ -378,7 +356,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

@@ -723,6 +723,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;
         }

svdtools/patch.py

@@ -405,13 +405,11 @@ class Device:
     def __init__(self, device):
         self.device = device
 
-    def iter_peripherals(self, pspec, check_derived=True):
+    def iter_peripherals(self, pspec):
         """Iterates over all peripherals that match pspec."""
         for ptag in self.device.iter("peripheral"):
             name = ptag.find("name").text
             if matchname(name, pspec):
-                if check_derived and "derivedFrom" in ptag.attrib:
-                    continue
                 yield ptag
 
     def modify_child(self, key, val):
@@ -491,7 +489,7 @@ def add_peripheral(self, pname, padd):
 
     def delete_peripheral(self, pspec):
         """Delete registers matched by rspec inside ptag."""
-        for ptag in list(self.iter_peripherals(pspec, check_derived=False)):
+        for ptag in list(self.iter_peripherals(pspec)):
             self.device.find("peripherals").remove(ptag)
 
     def derive_peripheral(self, pname, pderive):
@@ -586,15 +584,17 @@ def rebase_peripheral(self, pnew, pold):
 
     def clear_fields(self, pspec):
         """Clear contents of all fields inside peripherals matched by pspec"""
-        for ptag in self.iter_peripherals(pspec, check_derived=False):
+        for ptag in self.iter_peripherals(pspec):
+            if "derivedFrom" in ptag.attrib:
+                continue
             p = Peripheral(ptag)
             p.clear_fields("*")
 
     def process_peripheral(self, pspec, peripheral, update_fields=True):
         """Work through a peripheral, handling all registers."""
         # Find all peripherals that match the spec
         pcount = 0
-        for ptag in self.iter_peripherals(pspec, check_derived=False):
+        for ptag in self.iter_peripherals(pspec):
             pcount += 1
             p = Peripheral(ptag)
 
@@ -1024,6 +1024,8 @@ def collect_in_cluster(self, cname, cmod):
     def clear_fields(self, rspec):
         """Clear contents of all fields inside registers matched by rspec"""
         for rtag in list(self.iter_registers(rspec)):
+            if "derivedFrom" in rtag.attrib:
+                continue
             r = Register(rtag)
             r.clear_field("*")
 
@@ -1033,6 +1035,8 @@ def process_register(self, rspec, register, update_fields=True):
         pname = self.ptag.find("name").text
         rcount = 0
         for rtag in self.iter_registers(rspec):
+            if "derivedFrom" in rtag.attrib:
+                continue
             r = Register(rtag)
             rcount += 1
             # Handle deletions
@@ -1195,6 +1199,8 @@ def delete_field(self, fspec):
     def clear_field(self, fspec):
         """Clear contents of fields matched by fspec inside rtag."""
         for ftag in list(self.iter_fields(fspec)):
+            if "derivedFrom" in ftag.attrib:
+                continue
             for tag in ftag.findall("enumeratedValues"):
                 ftag.remove(tag)
             for tag in ftag.findall("writeConstraint"):