registers_or_clusters_first

Author: burrbull

svd-encoder/src/config.rs

@@ -4,7 +4,7 @@ use convert_case::{Boundary, Case, Casing};
 
 use crate::svd::BitRangeType;
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum IdentifierFormat {
     /// `Camel` case
     ///
@@ -63,7 +63,7 @@ pub fn change_case(s: &str, case: Option<IdentifierFormat>) -> String {
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum NumberFormat {
     /// `UpperHex` format
     ///
@@ -186,6 +186,24 @@ impl FromStr for Sorting {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RegistersOrClustersFirst {
+    Registers,
+    Clusters,
+}
+
+impl FromStr for RegistersOrClustersFirst {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "Registers" => Ok(Self::Registers),
+            "Clusters" => Ok(Self::Clusters),
+            _ => Err(()),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug)]
 #[non_exhaustive]
 /// Advanced encoder options
@@ -235,6 +253,9 @@ pub struct Config {
     /// Sort registers and clusters in specified order
     pub register_cluster_sorting: Option<Sorting>,
 
+    /// First write registers or clusters
+    pub registers_or_clusters_first: Option<RegistersOrClustersFirst>,
+
     /// Format of register's name-kind elements
     /// - `derivedFrom`
     /// - `name`
@@ -314,6 +335,7 @@ impl Default for Config {
             cluster_name: None,
             cluster_address_offset: NumberFormat::UpperHex,
             register_cluster_sorting: None,
+            registers_or_clusters_first: None,
             register_name: None,
             register_address_offset: NumberFormat::UpperHex,
             register_size: NumberFormat::LowerHex,
@@ -349,6 +371,9 @@ impl Config {
             "register_cluster_sorting" => {
                 self.register_cluster_sorting = Some(value.parse().unwrap())
             }
+            "registers_or_clusters_first" => {
+                self.registers_or_clusters_first = Some(value.parse().unwrap())
+            }
             "register_name" => self.register_name = Some(value.parse().unwrap()),
             "register_address_offset" => self.register_address_offset = value.parse().unwrap(),
             "register_size" => self.register_size = value.parse().unwrap(),
@@ -437,6 +462,14 @@ impl Config {
         self
     }
 
+    /// First write registers or clusters
+    ///
+    /// `None` means only `register_cluster_sorting` does matter
+    pub fn registers_or_clusters_first(mut self, val: Option<RegistersOrClustersFirst>) -> Self {
+        self.registers_or_clusters_first = val;
+        self
+    }
+
     /// Format of register's name-kind elements
     pub fn register_name(mut self, val: Option<IdentifierFormat>) -> Self {
         self.register_name = val;

svd-encoder/src/lib.rs

@@ -6,7 +6,9 @@ use svd_rs as svd;
 use crate::svd::Device;
 use xmltree::{Element, EmitterConfig, XMLNode};
 
-pub use crate::config::{Config, IdentifierFormat, NumberFormat, Sorting};
+pub use crate::config::{
+    Config, IdentifierFormat, NumberFormat, RegistersOrClustersFirst, Sorting,
+};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum EncodeError {}

svd-encoder/src/peripheral.rs

@@ -1,3 +1,5 @@
+use svd_rs::RegisterCluster;
+
 use super::{
     new_node, Config, Element, ElementMerge, Encode, EncodeChildren, EncodeError, XMLNode,
 };
@@ -102,24 +104,41 @@ impl Encode for PeripheralInfo {
         elem.children.append(&mut interrupts?);
 
         if let Some(v) = &self.registers {
-            let children: Result<Vec<_>, _> = if let Some(sorting) = config.register_cluster_sorting
-            {
-                let mut refs = v.iter().collect::<Vec<_>>();
-                match sorting {
-                    Sorting::Offset => refs.sort_by_key(|r| r.address_offset()),
-                    Sorting::OffsetReversed => {
-                        refs.sort_by_key(|r| -(r.address_offset() as i32));
+            let children: Result<Vec<_>, _> =
+                if let Some(first) = config.registers_or_clusters_first {
+                    let mut reg_refs = v
+                        .iter()
+                        .filter(|rc| matches!(rc, RegisterCluster::Register(_)))
+                        .collect::<Vec<_>>();
+                    sort_register_cluster(&mut reg_refs, config.register_cluster_sorting);
+                    let mut c_refs = v
+                        .iter()
+                        .filter(|rc| matches!(rc, RegisterCluster::Cluster(_)))
+                        .collect::<Vec<_>>();
+                    sort_register_cluster(&mut c_refs, config.register_cluster_sorting);
+                    match first {
+                        crate::RegistersOrClustersFirst::Registers => {
+                            reg_refs.into_iter().chain(c_refs.into_iter())
+                        }
+                        crate::RegistersOrClustersFirst::Clusters => {
+                            c_refs.into_iter().chain(reg_refs.into_iter())
+                        }
                     }
-                    Sorting::Name => refs.sort_by_key(|r| r.name()),
-                }
-                refs.into_iter()
-                    .map(|e| e.encode_node_with_config(config))
-                    .collect()
-            } else {
-                v.iter()
                     .map(|e| e.encode_node_with_config(config))
                     .collect()
-            };
+                } else {
+                    if let Some(sorting) = config.register_cluster_sorting {
+                        let mut refs = v.iter().collect::<Vec<_>>();
+                        sort_register_cluster(&mut refs, Some(sorting));
+                        refs.into_iter()
+                            .map(|e| e.encode_node_with_config(config))
+                            .collect()
+                    } else {
+                        v.iter()
+                            .map(|e| e.encode_node_with_config(config))
+                            .collect()
+                    }
+                };
 
             elem.children.push({
                 let mut e = Element::new("registers");
@@ -138,3 +157,15 @@ impl Encode for PeripheralInfo {
         Ok(elem)
     }
 }
+
+fn sort_register_cluster(refs: &mut [&RegisterCluster], sorting: Option<Sorting>) {
+    if let Some(sorting) = sorting {
+        match sorting {
+            Sorting::Offset => refs.sort_by_key(|r| r.address_offset()),
+            Sorting::OffsetReversed => {
+                refs.sort_by_key(|r| -(r.address_offset() as i32));
+            }
+            Sorting::Name => refs.sort_by_key(|r| r.name()),
+        }
+    }
+}