Merge pull request #130 from stm32-rs/arrays

add/modify arrays (rust)

Author: burrbull

Cargo.toml

@@ -27,8 +27,8 @@ edition = "2021"
 clap = { version = "3.2", features = ["derive", "cargo"] }
 serde = { version = "1.0", features = ["derive"] }
 quick-xml = { version = "0.25", features = ["serialize"] }
-svd-rs = { version = "0.14.0", features = ["serde", "derive-from"] }
-svd-parser = { version = "0.14.0", features = ["expand"] }
+svd-rs = { version = "0.14.1", features = ["serde", "derive-from"] }
+svd-parser = { version = "0.14.1", features = ["expand"] }
 svd-encoder = "0.14.1"
 yaml-rust = "0.4"
 # serde_yaml 0.9.x looks broken

src/patch/device.rs

@@ -6,11 +6,11 @@ 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};
+use super::{make_dim_element, modify_dim_element, modify_register_properties};
 
 pub type PerMatchIterMut<'a, 'b> = MatchIter<'b, std::slice::IterMut<'a, Peripheral>>;
 
@@ -219,31 +219,37 @@ impl DeviceExt for Device {
 
     fn modify_peripheral(&mut self, pspec: &str, pmod: &Hash) -> PatchResult {
         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 {
-                    let iname = iname.str()?;
-                    let int = make_interrupt(val.hash()?)?;
-                    for i in &mut ptag.interrupt {
-                        if i.name == iname {
-                            i.modify_from(int, VAL_LVL)?;
-                            break;
+        let ptags = self.iter_peripherals(pspec).collect::<Vec<_>>();
+        if !ptags.is_empty() {
+            let peripheral_builder = make_peripheral(pmod, true)?;
+            let dim = make_dim_element(pmod)?;
+            for ptag in ptags {
+                modified.insert(ptag.name.clone());
+
+                modify_dim_element(ptag, &dim)?;
+                ptag.modify_from(peripheral_builder.clone(), VAL_LVL)?;
+                if let Some(ints) = pmod.get_hash("interrupts")? {
+                    for (iname, val) in ints {
+                        let iname = iname.str()?;
+                        let int = make_interrupt(val.hash()?)?;
+                        for i in &mut ptag.interrupt {
+                            if i.name == iname {
+                                i.modify_from(int, VAL_LVL)?;
+                                break;
+                            }
                         }
                     }
                 }
-            }
-            if let Some(abmod) = pmod.get_hash("addressBlock").ok().flatten() {
-                let v = &mut ptag.address_block;
-                let ab = make_address_block(abmod)?;
-                match v.as_deref_mut() {
-                    Some([adb]) => adb.modify_from(ab, VAL_LVL)?,
-                    _ => *v = Some(vec![ab.build(VAL_LVL)?]),
+                if let Some(abmod) = pmod.get_hash("addressBlock").ok().flatten() {
+                    let v = &mut ptag.address_block;
+                    let ab = make_address_block(abmod)?;
+                    match v.as_deref_mut() {
+                        Some([adb]) => adb.modify_from(ab, VAL_LVL)?,
+                        _ => *v = Some(vec![ab.build(VAL_LVL)?]),
+                    }
+                } else if let Some(abmod) = pmod.get_vec("addressBlocks").ok().flatten() {
+                    ptag.address_block = Some(make_address_blocks(abmod)?);
                 }
-            } else if let Some(abmod) = pmod.get_vec("addressBlocks").ok().flatten() {
-                ptag.address_block = Some(make_address_blocks(abmod)?);
             }
         }
         // If this peripheral has derivations, update the derived
@@ -265,12 +271,16 @@ impl DeviceExt for Device {
             return Err(anyhow!("device already has a peripheral {pname}"));
         }
 
-        self.peripherals.push(
-            make_peripheral(padd, false)?
-                .name(pname.to_string())
-                .build(VAL_LVL)?
-                .single(),
-        );
+        let pnew = make_peripheral(padd, false)?
+            .name(pname.to_string())
+            .build(VAL_LVL)?;
+        let pnew = if let Some(dim) = make_dim_element(padd)? {
+            pnew.array(dim.build(VAL_LVL)?)
+        } else {
+            pnew.single()
+        };
+
+        self.peripherals.push(pnew);
         Ok(())
     }
 

src/patch/mod.rs

@@ -11,9 +11,11 @@ use svd_parser::svd::{
     PeripheralInfo, PeripheralInfoBuilder, RegisterCluster, RegisterInfo, RegisterInfoBuilder,
     RegisterProperties, Usage, ValidateLevel,
 };
+use svd_parser::SVDError::DimIndexParse;
+use svd_rs::{DimElement, DimElementBuilder, MaybeArray};
 use yaml_rust::{yaml::Hash, Yaml, YamlLoader};
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Context, Ok, Result};
 pub type PatchResult = anyhow::Result<()>;
 
 mod device;
@@ -304,6 +306,55 @@ fn make_address_block(h: &Hash) -> Result<AddressBlockBuilder> {
     Ok(ab)
 }
 
+fn make_dim_element(h: &Hash) -> Result<Option<DimElementBuilder>> {
+    let mut d = DimElement::builder()
+        .dim_index(if let Some(y) = h.get(&"dimIndex".to_yaml()) {
+            match y {
+                Yaml::String(text) => Some(DimElement::parse_indexes(text).ok_or(DimIndexParse)?),
+                Yaml::Array(a) => {
+                    let mut v = Vec::new();
+                    for s in a {
+                        v.push(s.as_str().ok_or(DimIndexParse)?.to_string());
+                    }
+                    Some(v)
+                }
+                _ => return Err(DimIndexParse).map_err(Into::into),
+            }
+        } else {
+            None
+        })
+        .dim_name(h.get_string("dimName")?)
+        // TODO
+        .dim_array_index(None);
+    if let Some(dim) = h.get_u32("dim")? {
+        d = d.dim(dim)
+    }
+    if let Some(dim_increment) = h.get_u32("dimIncrement")? {
+        d = d.dim_increment(dim_increment)
+    }
+    Ok(if d == DimElement::builder() {
+        None
+    } else {
+        Some(d)
+    })
+}
+
+fn modify_dim_element<T: Clone>(
+    tag: &mut MaybeArray<T>,
+    dim: &Option<DimElementBuilder>,
+) -> PatchResult {
+    if let Some(dim) = dim.as_ref() {
+        match tag {
+            MaybeArray::Array(_, array_info) => array_info.modify_from(dim.clone(), VAL_LVL)?,
+            MaybeArray::Single(info) => {
+                let array_info = dim.clone().build(VAL_LVL)?;
+                *tag = MaybeArray::Array(info.clone(), array_info);
+            }
+        }
+    }
+    Ok(())
+}
+
 fn make_field(fadd: &Hash) -> Result<FieldInfoBuilder> {
     let mut fnew = FieldInfo::builder()
         .description(fadd.get_string("description")?)

src/patch/peripheral.rs

@@ -7,7 +7,10 @@ use yaml_rust::{yaml::Hash, Yaml};
 use super::iterators::{MatchIter, Matched};
 use super::register::{RegisterExt, RegisterInfoExt};
 use super::yaml_ext::{AsType, GetVal, ToYaml};
-use super::{check_offsets, matchname, matchsubspec, spec_ind, PatchResult, VAL_LVL};
+use super::{
+    check_offsets, make_dim_element, matchname, matchsubspec, modify_dim_element, spec_ind,
+    PatchResult, VAL_LVL,
+};
 use super::{make_cluster, make_interrupt, make_register};
 
 use svd::registercluster::{AllRegistersIterMut, ClusterIterMut};
@@ -328,10 +331,16 @@ impl PeripheralExt for Peripheral {
     }
 
     fn modify_register(&mut self, rspec: &str, rmod: &Hash) -> PatchResult {
-        for rtag in self.iter_registers(rspec) {
-            rtag.modify_from(make_register(rmod)?, VAL_LVL)?;
-            if let Some("") = rmod.get_str("access")? {
-                rtag.properties.access = None;
+        let rtags = self.iter_registers(rspec).collect::<Vec<_>>();
+        if !rtags.is_empty() {
+            let register_builder = make_register(rmod)?;
+            let dim = make_dim_element(rmod)?;
+            for rtag in rtags {
+                modify_dim_element(rtag, &dim)?;
+                rtag.modify_from(register_builder.clone(), VAL_LVL)?;
+                if let Some("") = rmod.get_str("access")? {
+                    rtag.properties.access = None;
+                }
             }
         }
         Ok(())
@@ -346,12 +355,14 @@ impl PeripheralExt for Peripheral {
         }
         self.registers
             .get_or_insert_with(Default::default)
-            .push(RegisterCluster::Register(
-                make_register(radd)?
-                    .name(rname.into())
-                    .build(VAL_LVL)?
-                    .single(),
-            ));
+            .push(RegisterCluster::Register({
+                let reg = make_register(radd)?.name(rname.into()).build(VAL_LVL)?;
+                if let Some(dim) = make_dim_element(radd)? {
+                    reg.array(dim.build(VAL_LVL)?)
+                } else {
+                    reg.single()
+                }
+            }));
         Ok(())
     }
 

src/patch/register.rs

@@ -7,7 +7,9 @@ use yaml_rust::{yaml::Hash, Yaml};
 
 use super::iterators::{MatchIter, Matched};
 use super::yaml_ext::{AsType, GetVal, ToYaml};
-use super::{check_offsets, matchname, spec_ind, PatchResult, VAL_LVL};
+use super::{
+    check_offsets, make_dim_element, matchname, modify_dim_element, spec_ind, PatchResult, VAL_LVL,
+};
 use super::{make_derived_enumerated_values, make_ev_array, make_ev_name, make_field};
 
 pub type FieldMatchIterMut<'a, 'b> = MatchIter<'b, std::slice::IterMut<'a, Field>>;
@@ -215,35 +217,41 @@ impl RegisterExt for Register {
     }
 
     fn modify_field(&mut self, fspec: &str, fmod: &Hash) -> PatchResult {
-        for ftag in self.iter_fields(fspec) {
-            if let Some(value) = fmod
-                .get(&"_write_constraint".to_yaml())
-                .or_else(|| fmod.get(&"writeConstraint".to_yaml()))
-            {
-                let wc = match value {
-                    Yaml::String(s) if s == "none" => {
-                        // Completely remove the existing writeConstraint
-                        None
-                    }
-                    Yaml::String(s) if s == "enum" => {
-                        // Only allow enumerated values
-                        Some(WriteConstraint::UseEnumeratedValues(true))
-                    }
-                    Yaml::Array(a) => {
-                        // Allow a certain range
-                        Some(WriteConstraint::Range(WriteConstraintRange {
-                            min: a[0].i64()? as u64,
-                            max: a[1].i64()? as u64,
-                        }))
-                    }
-                    _ => return Err(anyhow!("Unknown writeConstraint type {value:?}")),
-                };
-                ftag.write_constraint = wc;
-            }
-            // For all other tags, just set the value
-            ftag.modify_from(make_field(fmod)?, VAL_LVL)?;
-            if let Some("") = fmod.get_str("access")? {
-                ftag.access = None;
+        let ftags = self.iter_fields(fspec).collect::<Vec<_>>();
+        let field_builder = make_field(fmod)?;
+        let dim = make_dim_element(fmod)?;
+        if !ftags.is_empty() {
+            for ftag in ftags {
+                modify_dim_element(ftag, &dim)?;
+                if let Some(value) = fmod
+                    .get(&"_write_constraint".to_yaml())
+                    .or_else(|| fmod.get(&"writeConstraint".to_yaml()))
+                {
+                    let wc = match value {
+                        Yaml::String(s) if s == "none" => {
+                            // Completely remove the existing writeConstraint
+                            None
+                        }
+                        Yaml::String(s) if s == "enum" => {
+                            // Only allow enumerated values
+                            Some(WriteConstraint::UseEnumeratedValues(true))
+                        }
+                        Yaml::Array(a) => {
+                            // Allow a certain range
+                            Some(WriteConstraint::Range(WriteConstraintRange {
+                                min: a[0].i64()? as u64,
+                                max: a[1].i64()? as u64,
+                            }))
+                        }
+                        _ => return Err(anyhow!("Unknown writeConstraint type {value:?}")),
+                    };
+                    ftag.write_constraint = wc;
+                }
+                // For all other tags, just set the value
+                ftag.modify_from(field_builder.clone(), VAL_LVL)?;
+                if let Some("") = fmod.get_str("access")? {
+                    ftag.access = None;
+                }
             }
         }
         Ok(())
@@ -256,11 +264,12 @@ impl RegisterExt for Register {
                 self.name
             ));
         }
-        // TODO: add field arrays
-        let fnew = make_field(fadd)?
-            .name(fname.into())
-            .build(VAL_LVL)?
-            .single();
+        let fnew = make_field(fadd)?.name(fname.into()).build(VAL_LVL)?;
+        let fnew = if let Some(dim) = make_dim_element(fadd)? {
+            fnew.array(dim.build(VAL_LVL)?)
+        } else {
+            fnew.single()
+        };
         self.fields.get_or_insert_with(Default::default).push(fnew);
         Ok(())
     }