Merge #161

bors[bot] · burrbull · web-flow · commit b7e987ede370 · 2021-11-07T05:20:17.000Z
161: peripheral array r=Emilgardis a=burrbull Closes #41 Co-authored-by: Andrey Zgarbul <zgarbul.andrey@gmail.com>
diff --git a/svd-encoder/CHANGELOG.md b/svd-encoder/CHANGELOG.md
@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## Unreleased
+
+- Add array support for peripherals
+
 ## [v0.11.0] - 2021-10-02
 - Splitted from `svd-parser`
 
diff --git a/svd-encoder/src/cluster.rs b/svd-encoder/src/cluster.rs
@@ -7,8 +7,8 @@ impl Encode for Cluster {
 
     fn encode(&self) -> Result<Element, EncodeError> {
         match self {
-            Cluster::Single(i) => i.encode(),
-            Cluster::Array(i, a) => {
+            Self::Single(i) => i.encode(),
+            Self::Array(i, a) => {
                 let mut e = Element::new("cluster");
                 e.merge(&a.encode()?);
                 e.merge(&i.encode()?);
diff --git a/svd-encoder/src/field.rs b/svd-encoder/src/field.rs
@@ -7,8 +7,8 @@ impl Encode for Field {
 
     fn encode(&self) -> Result<Element, EncodeError> {
         match self {
-            Field::Single(info) => info.encode(),
-            Field::Array(info, array_info) => {
+            Self::Single(info) => info.encode(),
+            Self::Array(info, array_info) => {
                 let mut base = Element::new("field");
                 base.merge(&array_info.encode()?);
                 base.merge(&info.encode()?);
diff --git a/svd-encoder/src/lib.rs b/svd-encoder/src/lib.rs
@@ -78,6 +78,7 @@ mod fieldinfo;
 mod interrupt;
 mod modifiedwritevalues;
 mod peripheral;
+mod peripheralinfo;
 mod register;
 mod registercluster;
 mod registerinfo;
diff --git a/svd-encoder/src/peripheral.rs b/svd-encoder/src/peripheral.rs
@@ -1,63 +1,19 @@
-use super::{new_node, Element, Encode, EncodeChildren, EncodeError, XMLNode};
+use super::{Element, ElementMerge, Encode, EncodeError};
 
-use crate::svd::{Interrupt, Peripheral};
+use crate::svd::Peripheral;
 
 impl Encode for Peripheral {
     type Error = EncodeError;
 
     fn encode(&self) -> Result<Element, EncodeError> {
-        let mut elem = Element::new("peripheral");
-        elem.children.push(new_node("name", self.name.clone()));
-
-        if let Some(v) = &self.display_name {
-            elem.children.push(new_node("displayName", v.to_string()));
-        }
-
-        if let Some(v) = &self.version {
-            elem.children.push(new_node("version", v.to_string()));
-        }
-
-        if let Some(v) = &self.description {
-            elem.children.push(new_node("description", v.to_string()));
-        }
-
-        if let Some(v) = &self.group_name {
-            elem.children.push(new_node("groupName", v.to_string()));
-        }
-        elem.children.push(new_node(
-            "baseAddress",
-            format!("0x{:.08X}", self.base_address),
-        ));
-
-        elem.children
-            .extend(self.default_register_properties.encode()?);
-
-        if let Some(v) = &self.address_block {
-            for ab in v {
-                elem.children.push(ab.encode_node()?);
+        match self {
+            Self::Single(info) => info.encode(),
+            Self::Array(info, array_info) => {
+                let mut base = Element::new("peripheral");
+                base.merge(&array_info.encode()?);
+                base.merge(&info.encode()?);
+                Ok(base)
             }
         }
-
-        let interrupts: Result<Vec<_>, _> =
-            self.interrupt.iter().map(Interrupt::encode_node).collect();
-
-        elem.children.append(&mut interrupts?);
-
-        if let Some(v) = &self.registers {
-            let children: Result<Vec<_>, _> = v.iter().map(|e| e.encode_node()).collect();
-
-            elem.children.push({
-                let mut e = Element::new("registers");
-                e.children = children?;
-                XMLNode::Element(e)
-            });
-        }
-
-        if let Some(v) = &self.derived_from {
-            elem.attributes
-                .insert(String::from("derivedFrom"), v.to_string());
-        }
-
-        Ok(elem)
     }
 }
diff --git a/svd-encoder/src/peripheralinfo.rs b/svd-encoder/src/peripheralinfo.rs
@@ -0,0 +1,63 @@
+use super::{new_node, Element, Encode, EncodeChildren, EncodeError, XMLNode};
+
+use crate::svd::{Interrupt, PeripheralInfo};
+
+impl Encode for PeripheralInfo {
+    type Error = EncodeError;
+
+    fn encode(&self) -> Result<Element, EncodeError> {
+        let mut elem = Element::new("peripheral");
+        elem.children.push(new_node("name", self.name.clone()));
+
+        if let Some(v) = &self.display_name {
+            elem.children.push(new_node("displayName", v.to_string()));
+        }
+
+        if let Some(v) = &self.version {
+            elem.children.push(new_node("version", v.to_string()));
+        }
+
+        if let Some(v) = &self.description {
+            elem.children.push(new_node("description", v.to_string()));
+        }
+
+        if let Some(v) = &self.group_name {
+            elem.children.push(new_node("groupName", v.to_string()));
+        }
+        elem.children.push(new_node(
+            "baseAddress",
+            format!("0x{:.08X}", self.base_address),
+        ));
+
+        elem.children
+            .extend(self.default_register_properties.encode()?);
+
+        if let Some(v) = &self.address_block {
+            for ab in v {
+                elem.children.push(ab.encode_node()?);
+            }
+        }
+
+        let interrupts: Result<Vec<_>, _> =
+            self.interrupt.iter().map(Interrupt::encode_node).collect();
+
+        elem.children.append(&mut interrupts?);
+
+        if let Some(v) = &self.registers {
+            let children: Result<Vec<_>, _> = v.iter().map(|e| e.encode_node()).collect();
+
+            elem.children.push({
+                let mut e = Element::new("registers");
+                e.children = children?;
+                XMLNode::Element(e)
+            });
+        }
+
+        if let Some(v) = &self.derived_from {
+            elem.attributes
+                .insert(String::from("derivedFrom"), v.to_string());
+        }
+
+        Ok(elem)
+    }
+}
diff --git a/svd-encoder/src/register.rs b/svd-encoder/src/register.rs
@@ -7,8 +7,8 @@ impl Encode for Register {
 
     fn encode(&self) -> Result<Element, EncodeError> {
         match self {
-            Register::Single(info) => info.encode(),
-            Register::Array(info, array_info) => {
+            Self::Single(info) => info.encode(),
+            Self::Array(info, array_info) => {
                 let mut base = Element::new("register");
                 base.merge(&array_info.encode()?);
                 base.merge(&info.encode()?);
diff --git a/svd-parser/CHANGELOG.md b/svd-parser/CHANGELOG.md
@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## Unreleased
+
+- Add array support for peripherals
+
 ## [v0.11.0] - 2021-10-02
 
 Previous versions in common [changelog][../CHANGELOG.md].
diff --git a/svd-parser/src/cluster.rs b/svd-parser/src/cluster.rs
@@ -26,9 +26,9 @@ impl Parse for Cluster {
                 }
             }
 
-            Ok(Cluster::Array(info, array_info))
+            Ok(Self::Array(info, array_info))
         } else {
-            Ok(Cluster::Single(info))
+            Ok(Self::Single(info))
         }
     }
 }
diff --git a/svd-parser/src/field.rs b/svd-parser/src/field.rs
@@ -26,9 +26,9 @@ impl Parse for Field {
                     .at(tree.id()));
                 }
             }
-            Ok(Field::Array(info, array_info))
+            Ok(Self::Array(info, array_info))
         } else {
-            Ok(Field::Single(info))
+            Ok(Self::Single(info))
         }
     }
 }
diff --git a/svd-parser/src/lib.rs b/svd-parser/src/lib.rs
@@ -162,6 +162,7 @@ mod fieldinfo;
 mod interrupt;
 mod modifiedwritevalues;
 mod peripheral;
+mod peripheralinfo;
 mod register;
 mod registercluster;
 mod registerinfo;
diff --git a/svd-parser/src/peripheral.rs b/svd-parser/src/peripheral.rs
@@ -1,5 +1,6 @@
 use super::*;
-use crate::svd::{AddressBlock, Interrupt, Peripheral, RegisterCluster, RegisterProperties};
+use crate::elementext::ElementExt;
+use crate::svd::{DimElement, Peripheral, PeripheralInfo};
 
 impl Parse for Peripheral {
     type Object = Self;
@@ -11,47 +12,23 @@ impl Parse for Peripheral {
             return Err(SVDError::NotExpectedTag("peripheral".to_string()).at(tree.id()));
         }
 
-        Peripheral::builder()
-            .name(tree.get_child_text("name")?)
-            .display_name(tree.get_child_text_opt("displayName")?)
-            .version(tree.get_child_text_opt("version")?)
-            .description(tree.get_child_text_opt("description")?)
-            .group_name(tree.get_child_text_opt("groupName")?)
-            .base_address(tree.get_child_u64("baseAddress")?)
-            .default_register_properties(RegisterProperties::parse(tree, config)?)
-            .address_block({
-                let ab: Result<Vec<_>, _> = tree
-                    .children()
-                    .filter(|t| t.is_element() && t.has_tag_name("addressBlock"))
-                    .map(|i| AddressBlock::parse(&i, config))
-                    .collect();
-                let ab = ab?;
-                if ab.is_empty() {
-                    None
-                } else {
-                    Some(ab)
+        let info = PeripheralInfo::parse(tree, config)?;
+
+        if tree.get_child("dimIncrement").is_some() {
+            let array_info = DimElement::parse(tree, config)?;
+            check_has_placeholder(&info.name, "peripheral").map_err(|e| e.at(tree.id()))?;
+            if let Some(indexes) = &array_info.dim_index {
+                if array_info.dim as usize != indexes.len() {
+                    return Err(SVDError::IncorrectDimIndexesCount(
+                        array_info.dim as usize,
+                        indexes.len(),
+                    )
+                    .at(tree.id()));
                 }
-            })
-            .interrupt({
-                let interrupt: Result<Vec<_>, _> = tree
-                    .children()
-                    .filter(|t| t.is_element() && t.has_tag_name("interrupt"))
-                    .map(|i| Interrupt::parse(&i, config))
-                    .collect();
-                Some(interrupt?)
-            })
-            .registers(if let Some(registers) = tree.get_child("registers") {
-                let rs: Result<Vec<_>, _> = registers
-                    .children()
-                    .filter(Node::is_element)
-                    .map(|t| RegisterCluster::parse(&t, config))
-                    .collect();
-                Some(rs?)
-            } else {
-                None
-            })
-            .derived_from(tree.attribute("derivedFrom").map(|s| s.to_owned()))
-            .build(config.validate_level)
-            .map_err(|e| SVDError::from(e).at(tree.id()))
+            }
+            Ok(Self::Array(info, array_info))
+        } else {
+            Ok(Self::Single(info))
+        }
     }
 }
diff --git a/svd-parser/src/peripheralinfo.rs b/svd-parser/src/peripheralinfo.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::svd::{AddressBlock, Interrupt, PeripheralInfo, RegisterCluster, RegisterProperties};
+
+impl Parse for PeripheralInfo {
+    type Object = Self;
+    type Error = SVDErrorAt;
+    type Config = Config;
+
+    fn parse(tree: &Node, config: &Self::Config) -> Result<Self, Self::Error> {
+        if !tree.has_tag_name("peripheral") {
+            return Err(SVDError::NotExpectedTag("peripheral".to_string()).at(tree.id()));
+        }
+
+        PeripheralInfo::builder()
+            .name(tree.get_child_text("name")?)
+            .display_name(tree.get_child_text_opt("displayName")?)
+            .version(tree.get_child_text_opt("version")?)
+            .description(tree.get_child_text_opt("description")?)
+            .group_name(tree.get_child_text_opt("groupName")?)
+            .base_address(tree.get_child_u64("baseAddress")?)
+            .default_register_properties(RegisterProperties::parse(tree, config)?)
+            .address_block({
+                let ab: Result<Vec<_>, _> = tree
+                    .children()
+                    .filter(|t| t.is_element() && t.has_tag_name("addressBlock"))
+                    .map(|i| AddressBlock::parse(&i, config))
+                    .collect();
+                let ab = ab?;
+                if ab.is_empty() {
+                    None
+                } else {
+                    Some(ab)
+                }
+            })
+            .interrupt({
+                let interrupt: Result<Vec<_>, _> = tree
+                    .children()
+                    .filter(|t| t.is_element() && t.has_tag_name("interrupt"))
+                    .map(|i| Interrupt::parse(&i, config))
+                    .collect();
+                Some(interrupt?)
+            })
+            .registers(if let Some(registers) = tree.get_child("registers") {
+                let rs: Result<Vec<_>, _> = registers
+                    .children()
+                    .filter(Node::is_element)
+                    .map(|t| RegisterCluster::parse(&t, config))
+                    .collect();
+                Some(rs?)
+            } else {
+                None
+            })
+            .derived_from(tree.attribute("derivedFrom").map(|s| s.to_owned()))
+            .build(config.validate_level)
+            .map_err(|e| SVDError::from(e).at(tree.id()))
+    }
+}
diff --git a/svd-parser/src/register.rs b/svd-parser/src/register.rs
@@ -26,9 +26,9 @@ impl Parse for Register {
                     .at(tree.id()));
                 }
             }
-            Ok(Register::Array(info, array_info))
+            Ok(Self::Array(info, array_info))
         } else {
-            Ok(Register::Single(info))
+            Ok(Self::Single(info))
         }
     }
 }
diff --git a/svd-rs/CHANGELOG.md b/svd-rs/CHANGELOG.md
@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add array support for peripherals
+
 ## [v0.11.2] - 2021-11-04
 
 - Implement `DeriveFrom` for `Cluster`, `Register` and `Field`
diff --git a/svd-rs/src/derive_from.rs b/svd-rs/src/derive_from.rs
diff --git a/svd-rs/src/lib.rs b/svd-rs/src/lib.rs
diff --git a/svd-rs/src/peripheral.rs b/svd-rs/src/peripheral.rs
diff --git a/svd-rs/src/peripheralinfo.rs b/svd-rs/src/peripheralinfo.rs

Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ impl Parse for Cluster {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`- Ok(Cluster::Array(info, array_info))`
	`29`	`+ Ok(Self::Array(info, array_info))`
`30`	`30`	`} else {`
`31`		`- Ok(Cluster::Single(info))`
	`31`	`+ Ok(Self::Single(info))`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,9 @@ impl Parse for Field {`
`26`	`26`	`.at(tree.id()));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`		`- Ok(Field::Array(info, array_info))`
	`29`	`+ Ok(Self::Array(info, array_info))`
`30`	`30`	`} else {`
`31`		`- Ok(Field::Single(info))`
	`31`	`+ Ok(Self::Single(info))`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`