Merge #74

74: Peripheral Cluster Defaults r=ryankurte a=burrbull

Add register ~~`Defaults`~~ `RegisterProperties` for Peripheral and ClusterInfo.

https://www.keil.com/pack/doc/CMSIS/SVD/html/elem_peripherals.html

Co-authored-by: Andrey Zgarbul <[email protected]>

Author: bors[bot]

src/error.rs

@@ -69,7 +69,7 @@ pub enum InvalidBitRange {
 }
 
 impl Fail for SVDError {
-    fn cause(&self) -> Option<&Fail> {
+    fn cause(&self) -> Option<&dyn Fail> {
         self.inner.cause()
     }
 

src/lib.rs

@@ -103,7 +103,7 @@ pub fn run_test<
 ) {
     for t in tests {
         let mut tree1 = Element::parse(t.1.as_bytes()).unwrap();
-        let mut elem = T::parse(&tree1).unwrap();
+        let elem = T::parse(&tree1).unwrap();
         // Hack to make assert be order agnostic
         tree1.children.sort_by(|e1,e2| e1.name.cmp(&e2.name));
         tree1.children.iter_mut().for_each(|e| { 

src/svd/cluster.rs

@@ -68,8 +68,7 @@ impl Encode for Cluster {
     fn encode(&self) -> Result<Element, SVDError> {
         match self {
             Cluster::Single(i) => {
-                let mut e = i.encode()?;
-                Ok(e)
+                i.encode()
             }
             Cluster::Array(i, a) => {
                 let mut e = i.encode()?;

src/svd/clusterinfo.rs

@@ -4,25 +4,21 @@ use xmltree::Element;
 use types::Parse;
 
 #[cfg(feature = "unproven")]
-use encode::Encode;
+use encode::{Encode, EncodeChildren};
 #[cfg(feature = "unproven")]
 use new_element;
-use parse;
 
 use error::SVDError;
-use svd::access::Access;
 use svd::registercluster::RegisterCluster;
+use svd::registerproperties::RegisterProperties;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ClusterInfo {
     pub name: String,
     pub description: String,
     pub header_struct_name: Option<String>,
     pub address_offset: u32,
-    pub size: Option<u32>,
-    pub access: Option<Access>,
-    pub reset_value: Option<u32>,
-    pub reset_mask: Option<u32>,
+    pub default_register_properties: RegisterProperties,
     pub children: Vec<RegisterCluster>,
     // Reserve the right to add more fields to this struct
     _extensible: (),
@@ -38,11 +34,7 @@ impl Parse for ClusterInfo {
             description: tree.get_child_text("description")?,
             header_struct_name: tree.get_child_text_opt("headerStructName")?,
             address_offset: tree.get_child_u32("addressOffset")?,
-            size: parse::optional::<u32>("size", tree)?,
-            //access: tree.get_child("access").map(|t| Access::parse(t).ok() ),
-            access: parse::optional::<Access>("access", tree)?,
-            reset_value: parse::optional::<u32>("resetValue", tree)?,
-            reset_mask: parse::optional::<u32>("resetMask", tree)?,
+            default_register_properties: RegisterProperties::parse(tree)?,
             children: {
                 let children: Result<Vec<_>, _> = tree.children
                     .iter()
@@ -77,26 +69,7 @@ impl Encode for ClusterInfo {
             Some(format!("{}", self.address_offset)),
         ));
 
-        if let Some(ref v) = self.size {
-            e.children
-                .push(new_element("size", Some(format!("{}", v))));
-        }
-
-        if let Some(ref v) = self.access {
-            e.children.push(v.encode()?);
-        }
-
-        if let Some(ref v) = self.reset_value {
-            e.children.push(new_element(
-                "resetValue",
-                Some(format!("{}", v)),
-            ));
-        }
-
-        if let Some(ref v) = self.reset_mask {
-            e.children
-                .push(new_element("resetMask", Some(format!("{}", v))));
-        }
+        e.children.extend(self.default_register_properties.encode()?);
 
         for c in &self.children {
             e.children.push(c.encode()?);

src/svd/device.rs

@@ -7,12 +7,12 @@ use parse;
 use types::Parse;
 
 #[cfg(feature = "unproven")]
-use encode::Encode;
+use encode::{Encode, EncodeChildren};
 use error::SVDError;
 #[cfg(feature = "unproven")]
 use new_element;
 use svd::cpu::Cpu;
-use svd::defaults::Defaults;
+use svd::registerproperties::RegisterProperties;
 use svd::peripheral::Peripheral;
 
 #[derive(Clone, Debug)]
@@ -25,7 +25,7 @@ pub struct Device {
     pub width: Option<u32>,
     pub cpu: Option<Cpu>,
     pub peripherals: Vec<Peripheral>,
-    pub defaults: Defaults,
+    pub default_register_properties: RegisterProperties,
     // Reserve the right to add more fields to this struct
     _extensible: (),
 }
@@ -54,7 +54,7 @@ impl Parse for Device {
                     .collect();
                 ps?
             },
-            defaults: Defaults::parse(tree)?,
+            default_register_properties: RegisterProperties::parse(tree)?,
             _extensible: (),
         })
     }
@@ -120,6 +120,8 @@ impl Encode for Device {
             None => (),
         }
 
+        elem.children.extend(self.default_register_properties.encode()?);
+
         match self.cpu {
             Some(ref v) => {
                 elem.children.push(v.encode()?);

src/svd/mod.rs

@@ -34,8 +34,8 @@ pub use self::field::Field;
 pub mod registerinfo;
 pub use self::registerinfo::RegisterInfo;
 
-pub mod defaults;
-pub use self::defaults::Defaults;
+pub mod registerproperties;
+pub use self::registerproperties::RegisterProperties;
 
 pub mod addressblock;
 pub use self::addressblock::AddressBlock;

src/svd/peripheral.rs

@@ -8,7 +8,7 @@ use failure::ResultExt;
 use parse;
 
 #[cfg(feature = "unproven")]
-use encode::Encode;
+use encode::{Encode, EncodeChildren};
 #[cfg(feature = "unproven")]
 use new_element;
 use types::Parse;
@@ -17,6 +17,7 @@ use error::{SVDError, SVDErrorKind};
 use svd::addressblock::AddressBlock;
 use svd::interrupt::Interrupt;
 use svd::registercluster::RegisterCluster;
+use svd::registerproperties::RegisterProperties;
 
 #[derive(Clone, Debug)]
 pub struct Peripheral {
@@ -28,6 +29,7 @@ pub struct Peripheral {
     pub base_address: u32,
     pub address_block: Option<AddressBlock>,
     pub interrupt: Vec<Interrupt>,
+    pub default_register_properties: RegisterProperties,
     /// `None` indicates that the `<registers>` node is not present
     pub registers: Option<Vec<RegisterCluster>>,
     pub derived_from: Option<String>,
@@ -65,6 +67,9 @@ impl Peripheral {
         derived.description = derived
             .description
             .or_else(|| other.description.clone());
+        derived.default_register_properties = derived
+            .default_register_properties
+            .derive_from(&other.default_register_properties);
         derived.registers = derived
             .registers
             .or_else(|| other.registers.clone());
@@ -99,6 +104,7 @@ impl Peripheral {
                     .collect();
                 interrupt?
             },
+            default_register_properties: RegisterProperties::parse(tree)?,
             registers: if let Some(registers) = tree.get_child("registers") {
                 let rs: Result<Vec<_>, _> = registers
                     .children
@@ -165,6 +171,9 @@ impl Encode for Peripheral {
             "baseAddress",
             Some(format!("0x{:.08x}", self.base_address)),
         ));
+
+        elem.children.extend(self.default_register_properties.encode()?);
+
         match self.address_block {
             Some(ref v) => {
                 elem.children.push(v.encode()?);

src/svd/register.rs

@@ -60,7 +60,7 @@ impl Encode for Register {
             Register::Single(ref info) => info.encode(),
             Register::Array(ref info, ref array_info) => {
                 // TODO: is this correct? probably not, need tests
-                let mut base = info.encode()?;
+                let base = info.encode()?;
                 base.merge(&array_info.encode()?);
                 Ok(base)
             }

src/svd/registerinfo.rs

@@ -17,6 +17,7 @@ use svd::access::Access;
 use svd::field::Field;
 use svd::modifiedwritevalues::ModifiedWriteValues;
 use svd::writeconstraint::WriteConstraint;
+use svd::registerproperties::RegisterProperties;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct RegisterInfo {
@@ -55,17 +56,18 @@ impl Parse for RegisterInfo {
 
 impl RegisterInfo {
     fn _parse(tree: &Element, name: String) -> Result<RegisterInfo, SVDError> {
+        let properties = RegisterProperties::parse(tree)?;
         Ok(RegisterInfo {
             name,
             alternate_group: tree.get_child_text_opt("alternateGroup")?,
             alternate_register: tree.get_child_text_opt("alternateRegister")?,
             description: tree.get_child_text_opt("description")?,
             derived_from: tree.attributes.get("derivedFrom").map(|s| s.to_owned()),
             address_offset: tree.get_child_u32("addressOffset")?,
-            size: parse::optional::<u32>("size", tree)?,
-            access: parse::optional::<Access>("access", tree)?,
-            reset_value: parse::optional::<u32>("resetValue", tree)?,
-            reset_mask: parse::optional::<u32>("resetMask", tree)?,
+            size: properties.size,
+            access: properties.access,
+            reset_value: properties.reset_value,
+            reset_mask: properties.reset_mask,
             fields: {
                 if let Some(fields) = tree.get_child("fields") {
                     let fs: Result<Vec<_>, _> = fields

src/svd/defaults.rs renamed to src/svd/registerproperties.rs

@@ -14,7 +14,7 @@ use svd::access::Access;
 
 /// Register default properties
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Defaults {
+pub struct RegisterProperties {
     pub size: Option<u32>,
     pub reset_value: Option<u32>,
     pub reset_mask: Option<u32>,
@@ -23,12 +23,22 @@ pub struct Defaults {
     _extensible: (),
 }
 
-impl Parse for Defaults {
-    type Object = Defaults;
+impl RegisterProperties {
+    pub fn derive_from(mut self, other: &Self) -> Self {
+        self.size = self.size.or(other.size);
+        self.reset_value = self.reset_value.or(other.reset_value);
+        self.reset_mask = self.reset_mask.or(other.reset_mask);
+        self.access = self.access.or(other.access);
+        self
+    }
+}
+
+impl Parse for RegisterProperties {
+    type Object = RegisterProperties;
     type Error = SVDError;
 
-    fn parse(tree: &Element) -> Result<Defaults, SVDError> {
-        Ok(Defaults {
+    fn parse(tree: &Element) -> Result<RegisterProperties, SVDError> {
+        Ok(RegisterProperties {
             size: parse::optional::<u32>("size", tree)?,
             reset_value: parse::optional::<u32>("resetValue", tree)?,
             reset_mask: parse::optional::<u32>("resetMask", tree)?,
@@ -39,7 +49,7 @@ impl Parse for Defaults {
 }
 
 #[cfg(feature = "unproven")]
-impl EncodeChildren for Defaults {
+impl EncodeChildren for RegisterProperties {
     type Error = SVDError;
     fn encode(&self) -> Result<Vec<Element>, SVDError> {
         let mut children = Vec::new();
@@ -103,7 +113,7 @@ mod tests {
         ",
         );
 
-        let expected = Defaults {
+        let expected = RegisterProperties {
             size: Some(0xaabbccdd),
             reset_value: Some(0x11223344),
             reset_mask: Some(0x00000000),
@@ -113,7 +123,7 @@ mod tests {
 
         let tree1 = Element::parse(example.as_bytes()).unwrap();
 
-        let parsed = Defaults::parse(&tree1).unwrap();
+        let parsed = RegisterProperties::parse(&tree1).unwrap();
         assert_eq!(parsed, expected, "Parsing tree failed");
 
         let mut tree2 = new_element("mock", None);