Merge #207

207: feat: add advanced encoder options `Config` r=burrbull a=duskmoon314

- Add `convert_case` to dependencies
- Add advanced encoder options `Config`

BREAKING CHANGE
- `Encode` trait needs to implement `encode_with_config`

Co-authored-by: Campbell He <campbell.he@icloud.com>

Author: bors[bot]

svd-encoder/CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ## Unreleased
 
 - Bump MSRV to 1.56.0 (2021)
+- Add advanced encoder options `Config`
+- BREAKING: `Encode` trait needs to implement `encode_with_config`
 
 ## [v0.13.1] - 2022-02-12
 

svd-encoder/Cargo.toml

@@ -1,7 +1,5 @@
 [package]
-authors = [
-    "The Tools Team <tools@teams.rust-embedded.org>",
-]
+authors = ["The Tools Team <tools@teams.rust-embedded.org>"]
 description = "A CMSIS-SVD file encoder"
 documentation = "https://docs.rs/svd-encoder"
 keywords = ["CMSIS", "SVD", "encoder"]
@@ -14,6 +12,7 @@ version = "0.13.1"
 readme = "README.md"
 
 [dependencies]
+convert_case = "0.5.0"
 svd-rs = { version = "0.13.1", path = "../svd-rs" }
 thiserror = "1.0.30"
 

svd-encoder/src/access.rs

@@ -1,9 +1,9 @@
-use super::{Element, Encode, EncodeError, XMLNode};
+use super::{Config, Element, Encode, EncodeError, XMLNode};
 
 impl Encode for crate::svd::Access {
     type Error = EncodeError;
 
-    fn encode(&self) -> Result<Element, EncodeError> {
+    fn encode_with_config(&self, _config: &Config) -> Result<Element, EncodeError> {
         let mut elem = Element::new("access");
         elem.children.push(XMLNode::Text(self.as_str().to_string()));
         Ok(elem)

svd-encoder/src/addressblock.rs

@@ -1,12 +1,17 @@
-use super::{new_node, Element, Encode, EncodeError, XMLNode};
+use crate::config::format_number;
+
+use super::{new_node, Config, Element, Encode, EncodeError, XMLNode};
 
 impl Encode for crate::svd::AddressBlock {
     type Error = EncodeError;
 
-    fn encode(&self) -> Result<Element, EncodeError> {
+    fn encode_with_config(&self, config: &Config) -> Result<Element, EncodeError> {
         let mut children = vec![
-            new_node("offset", format!("0x{:X}", self.offset)),
-            new_node("size", format!("0x{:X}", self.size)),
+            new_node(
+                "offset",
+                format_number(self.offset, config.address_block_offset),
+            ),
+            new_node("size", format_number(self.size, config.address_block_size)),
             self.usage.encode_node()?,
         ];
         if let Some(v) = &self.protection {
@@ -21,7 +26,7 @@ impl Encode for crate::svd::AddressBlock {
 impl Encode for crate::svd::AddressBlockUsage {
     type Error = EncodeError;
 
-    fn encode(&self) -> Result<Element, EncodeError> {
+    fn encode_with_config(&self, _config: &Config) -> Result<Element, EncodeError> {
         let mut elem = Element::new("usage");
         elem.children.push(XMLNode::Text(self.as_str().to_string()));
         Ok(elem)

svd-encoder/src/bitrange.rs

@@ -1,18 +1,23 @@
-use super::{new_node, EncodeError, XMLNode};
-use crate::svd::{BitRange, BitRangeType};
+use super::{new_node, Config, EncodeError, XMLNode};
+use crate::{
+    config::FieldBitRangeFormat,
+    svd::{BitRange, BitRangeType},
+};
 
 // TODO: Encode method differs from Encode trait as it acts on a set of possible children, create an interface or decide how to better do this
-pub fn encode_bitrange(br: &BitRange) -> Result<Vec<XMLNode>, EncodeError> {
-    match br.range_type {
-        BitRangeType::BitRange => Ok(vec![new_node(
-            "bitRange",
-            format!("[{}:{}]", br.msb(), br.lsb()),
-        )]),
-        BitRangeType::MsbLsb => Ok(vec![
-            new_node("lsb", format!("{}", br.lsb())),
-            new_node("msb", format!("{}", br.msb())),
-        ]),
-        BitRangeType::OffsetWidth => Ok(vec![
+pub fn encode_bitrange(br: &BitRange, config: &Config) -> Result<Vec<XMLNode>, EncodeError> {
+    match (config.field_bit_range, br.range_type) {
+        (Some(FieldBitRangeFormat(BitRangeType::BitRange)), _) | (None, BitRangeType::BitRange) => {
+            Ok(vec![new_node("bitRange", br.bit_range())])
+        }
+        (Some(FieldBitRangeFormat(BitRangeType::MsbLsb)), _) | (None, BitRangeType::MsbLsb) => {
+            Ok(vec![
+                new_node("lsb", format!("{}", br.lsb())),
+                new_node("msb", format!("{}", br.msb())),
+            ])
+        }
+        (Some(FieldBitRangeFormat(BitRangeType::OffsetWidth)), _)
+        | (None, BitRangeType::OffsetWidth) => Ok(vec![
             new_node("bitOffset", format!("{}", br.offset)),
             new_node("bitWidth", format!("{}", br.width)),
         ]),

svd-encoder/src/cluster.rs

@@ -1,17 +1,22 @@
-use super::{new_node, Element, ElementMerge, Encode, EncodeChildren, EncodeError, XMLNode};
+use super::{
+    new_node, Config, Element, ElementMerge, Encode, EncodeChildren, EncodeError, XMLNode,
+};
 
-use crate::svd::{Cluster, ClusterInfo};
+use crate::{
+    config::{change_case, format_number},
+    svd::{Cluster, ClusterInfo},
+};
 
 impl Encode for Cluster {
     type Error = EncodeError;
 
-    fn encode(&self) -> Result<Element, EncodeError> {
+    fn encode_with_config(&self, config: &Config) -> Result<Element, EncodeError> {
         match self {
-            Self::Single(i) => i.encode(),
+            Self::Single(i) => i.encode_with_config(config),
             Self::Array(i, a) => {
                 let mut e = Element::new("cluster");
-                e.merge(&a.encode()?);
-                e.merge(&i.encode()?);
+                e.merge(&a.encode_with_config(config)?);
+                e.merge(&i.encode_with_config(config)?);
                 Ok(e)
             }
         }
@@ -21,17 +26,23 @@ impl Encode for Cluster {
 impl Encode for ClusterInfo {
     type Error = EncodeError;
 
-    fn encode(&self) -> Result<Element, EncodeError> {
+    fn encode_with_config(&self, config: &Config) -> Result<Element, EncodeError> {
         let mut e = Element::new("cluster");
 
-        e.children.push(new_node("name", self.name.clone()));
+        e.children.push(new_node(
+            "name",
+            change_case(&self.name, config.cluster_name),
+        ));
 
         if let Some(v) = &self.description {
             e.children.push(new_node("description", v.clone()));
         }
 
         if let Some(v) = &self.alternate_cluster {
-            e.children.push(new_node("alternateCluster", v.clone()));
+            e.children.push(new_node(
+                "alternateCluster",
+                change_case(v, config.cluster_name),
+            ));
         }
 
         if let Some(v) = &self.header_struct_name {
@@ -40,19 +51,24 @@ impl Encode for ClusterInfo {
 
         e.children.push(new_node(
             "addressOffset",
-            format!("{}", self.address_offset),
+            format_number(self.address_offset, config.cluster_address_offset),
         ));
 
-        e.children
-            .extend(self.default_register_properties.encode()?);
+        e.children.extend(
+            self.default_register_properties
+                .encode_with_config(config)?,
+        );
 
         for c in &self.children {
-            e.children.push(XMLNode::Element(c.encode()?));
+            e.children
+                .push(XMLNode::Element(c.encode_with_config(config)?));
         }
 
         if let Some(v) = &self.derived_from {
-            e.attributes
-                .insert(String::from("derivedFrom"), v.to_string());
+            e.attributes.insert(
+                String::from("derivedFrom"),
+                change_case(v, config.cluster_name),
+            );
         }
 
         Ok(e)