derived_last

Author: burrbull

svd-encoder/src/config.rs

@@ -150,7 +150,7 @@ where
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct FieldBitRangeFormat(pub BitRangeType);
 
 impl FromStr for FieldBitRangeFormat {
@@ -167,9 +167,14 @@ impl FromStr for FieldBitRangeFormat {
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+/// Apply a kind of sorting
 pub enum Sorting {
+    /// Sort by addresses of offsets
     Offset,
+    /// Same as [`Sorting::Offset`], but reversed
     OffsetReversed,
+    /// Sort by name
     Name,
 }
 
@@ -225,6 +230,9 @@ pub struct Config {
     /// Sort peripherals in specified order
     pub peripheral_sorting: Option<Sorting>,
 
+    /// Place derived peripherals in the end
+    pub peripheral_derived_last: bool,
+
     /// Format of addressBlock's offset element
     ///
     /// format: hex, dec
@@ -256,6 +264,9 @@ pub struct Config {
     /// First write registers or clusters
     pub registers_or_clusters_first: Option<RegistersOrClustersFirst>,
 
+    /// Place derived registers and clusters in the end
+    pub register_cluster_derived_last: bool,
+
     /// Format of register's name-kind elements
     /// - `derivedFrom`
     /// - `name`
@@ -295,6 +306,9 @@ pub struct Config {
     /// Sort fields in specified order
     pub field_sorting: Option<Sorting>,
 
+    /// Place derived fields in the end
+    pub field_derived_last: bool,
+
     /// Format of enumeratedValues's name-kind elements
     /// - `derivedFrom`
     /// - `name`
@@ -329,13 +343,15 @@ impl Default for Config {
             peripheral_name: None,
             peripheral_base_address: NumberFormat::UpperHex8,
             peripheral_sorting: None,
+            peripheral_derived_last: false,
             address_block_offset: NumberFormat::UpperHex,
             address_block_size: NumberFormat::UpperHex,
             interrupt_name: None,
             cluster_name: None,
             cluster_address_offset: NumberFormat::UpperHex,
             register_cluster_sorting: None,
             registers_or_clusters_first: None,
+            register_cluster_derived_last: false,
             register_name: None,
             register_address_offset: NumberFormat::UpperHex,
             register_size: NumberFormat::LowerHex,
@@ -344,6 +360,7 @@ impl Default for Config {
             field_name: None,
             field_bit_range: None,
             field_sorting: None,
+            field_derived_last: false,
             enumerated_values_name: None,
             enumerated_value_name: None,
             enumerated_value_value: NumberFormat::Dec,
@@ -363,6 +380,7 @@ impl Config {
             "peripheral_name" => self.peripheral_name = Some(value.parse().unwrap()),
             "peripheral_base_address" => self.peripheral_base_address = value.parse().unwrap(),
             "peripheral_sorting" => self.peripheral_sorting = Some(value.parse().unwrap()),
+            "peripheral_derived_last" => self.peripheral_derived_last = value.parse().unwrap(),
             "address_block_offset" => self.address_block_offset = value.parse().unwrap(),
             "address_block_size" => self.address_block_size = value.parse().unwrap(),
             "interrupt_name" => self.interrupt_name = Some(value.parse().unwrap()),
@@ -374,6 +392,9 @@ impl Config {
             "registers_or_clusters_first" => {
                 self.registers_or_clusters_first = Some(value.parse().unwrap())
             }
+            "register_cluster_derived_last" => {
+                self.register_cluster_derived_last = 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(),
@@ -382,6 +403,7 @@ impl Config {
             "field_name" => self.field_name = Some(value.parse().unwrap()),
             "field_bit_range" => self.field_bit_range = Some(value.parse().unwrap()),
             "field_sorting" => self.field_sorting = Some(value.parse().unwrap()),
+            "field_derived_last" => self.field_derived_last = value.parse().unwrap(),
             "enumerated_values_name" => self.enumerated_values_name = Some(value.parse().unwrap()),
             "enumerated_value_name" => self.enumerated_value_name = Some(value.parse().unwrap()),
             "enumerated_value_value" => self.enumerated_value_value = value.parse().unwrap(),
@@ -418,6 +440,14 @@ impl Config {
         self
     }
 
+    /// Place derived peripherals in the end
+    ///
+    /// `false` means keep the original order
+    pub fn peripheral_derived_last(mut self, val: bool) -> Self {
+        self.peripheral_derived_last = val;
+        self
+    }
+
     /// Format of addressBlock's offset element
     ///
     /// format: hex, dec
@@ -470,6 +500,14 @@ impl Config {
         self
     }
 
+    /// Place derived registers and clusters in the end
+    ///
+    /// `false` means keep the original order
+    pub fn register_cluster_derived_last(mut self, val: bool) -> Self {
+        self.register_cluster_derived_last = val;
+        self
+    }
+
     /// Format of register's name-kind elements
     pub fn register_name(mut self, val: Option<IdentifierFormat>) -> Self {
         self.register_name = val;
@@ -530,6 +568,14 @@ impl Config {
         self
     }
 
+    /// Place derived fields in the end
+    ///
+    /// `false` means keep the original order
+    pub fn field_derived_last(mut self, val: bool) -> Self {
+        self.field_derived_last = val;
+        self
+    }
+
     /// Format of enumeratedValues's name-kind elements
     pub fn enumerated_values_name(mut self, val: Option<IdentifierFormat>) -> Self {
         self.enumerated_values_name = val;

svd-encoder/src/device.rs

@@ -1,3 +1,5 @@
+use svd_rs::Peripheral;
+
 use super::{new_node, Config, Element, Encode, EncodeChildren, EncodeError, XMLNode};
 use crate::{config::Sorting, svd::Device};
 
@@ -57,24 +59,23 @@ impl Encode for Device {
                 .encode_with_config(config)?,
         );
 
-        let peripherals: Result<Vec<_>, _> = if let Some(sorting) = config.peripheral_sorting {
-            let mut refs = self.peripherals.iter().collect::<Vec<_>>();
-            match sorting {
-                Sorting::Offset => refs.sort_by_key(|p| p.base_address),
-                Sorting::OffsetReversed => {
-                    refs.sort_by_key(|p| -(p.base_address as i32));
-                }
-                Sorting::Name => refs.sort_by_key(|p| &p.name),
-            }
-            refs.into_iter()
-                .map(|peripheral| peripheral.encode_node_with_config(config))
-                .collect()
-        } else {
-            self.peripherals
-                .iter()
+        let peripherals: Result<Vec<_>, _> =
+            if !config.peripheral_derived_last && config.peripheral_sorting.is_none() {
+                self.peripherals
+                    .iter()
+                    .map(|peripheral| peripheral.encode_node_with_config(config))
+                    .collect()
+            } else {
+                sort_derived_peripherals(
+                    &self.peripherals,
+                    config.peripheral_sorting,
+                    config.peripheral_derived_last,
+                )
+                .into_iter()
                 .map(|peripheral| peripheral.encode_node_with_config(config))
                 .collect()
-        };
+            };
+
         elem.children.push({
             let mut e = Element::new("peripherals");
             e.children = peripherals?;
@@ -93,3 +94,40 @@ impl Encode for Device {
         Ok(elem)
     }
 }
+
+fn sort_peripherals(refs: &mut [&Peripheral], sorting: Option<Sorting>) {
+    if let Some(sorting) = sorting {
+        match sorting {
+            Sorting::Offset => refs.sort_by_key(|p| p.base_address),
+            Sorting::OffsetReversed => {
+                refs.sort_by_key(|p| -(p.base_address as i32));
+            }
+            Sorting::Name => refs.sort_by_key(|p| &p.name),
+        }
+    }
+}
+
+fn sort_derived_peripherals(
+    peripherals: &[Peripheral],
+    sorting: Option<Sorting>,
+    derived_last: bool,
+) -> Vec<&Peripheral> {
+    if derived_last {
+        let mut common_refs = peripherals
+            .iter()
+            .filter(|p| p.derived_from.is_none())
+            .collect::<Vec<_>>();
+        let mut derived_refs = peripherals
+            .iter()
+            .filter(|p| p.derived_from.is_some())
+            .collect::<Vec<_>>();
+        sort_peripherals(&mut common_refs, sorting);
+        sort_peripherals(&mut derived_refs, sorting);
+        common_refs.extend(derived_refs);
+        common_refs
+    } else {
+        let mut refs = peripherals.iter().collect::<Vec<_>>();
+        sort_peripherals(&mut refs, sorting);
+        refs
+    }
+}

svd-encoder/src/peripheral.rs

@@ -104,41 +104,53 @@ impl Encode for PeripheralInfo {
         elem.children.append(&mut interrupts?);
 
         if let Some(v) = &self.registers {
-            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())
-                        }
-                    }
+            let children: Result<Vec<_>, _> = if config.registers_or_clusters_first.is_none()
+                && !config.register_cluster_derived_last
+                && config.register_cluster_sorting.is_none()
+            {
+                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()
+            } else if let Some(first) = config.registers_or_clusters_first {
+                let reg_refs = v
+                    .iter()
+                    .filter(|rc| matches!(rc, RegisterCluster::Register(_)))
+                    .collect::<Vec<_>>();
+                let reg_refs = sort_derived_register_cluster(
+                    reg_refs,
+                    config.register_cluster_sorting,
+                    config.register_cluster_derived_last,
+                );
+
+                let c_refs = v
+                    .iter()
+                    .filter(|rc| matches!(rc, RegisterCluster::Cluster(_)))
+                    .collect::<Vec<_>>();
+                let c_refs = sort_derived_register_cluster(
+                    c_refs,
+                    config.register_cluster_sorting,
+                    config.register_cluster_derived_last,
+                );
+                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())
                     }
-                };
+                }
+                .map(|e| e.encode_node_with_config(config))
+                .collect()
+            } else {
+                sort_derived_register_cluster(
+                    v,
+                    config.register_cluster_sorting,
+                    config.register_cluster_derived_last,
+                )
+                .into_iter()
+                .map(|e| e.encode_node_with_config(config))
+                .collect()
+            };
 
             elem.children.push({
                 let mut e = Element::new("registers");
@@ -169,3 +181,29 @@ fn sort_register_cluster(refs: &mut [&RegisterCluster], sorting: Option<Sorting>
         }
     }
 }
+
+fn sort_derived_register_cluster<'a>(
+    rcs: impl IntoIterator<Item = &'a RegisterCluster>,
+    sorting: Option<Sorting>,
+    derived_last: bool,
+) -> Vec<&'a RegisterCluster> {
+    if derived_last {
+        let mut common_refs = Vec::new();
+        let mut derived_refs = Vec::new();
+        for rc in rcs {
+            if rc.derived_from().is_some() {
+                derived_refs.push(rc);
+            } else {
+                common_refs.push(rc);
+            }
+        }
+        sort_register_cluster(&mut common_refs, sorting);
+        sort_register_cluster(&mut derived_refs, sorting);
+        common_refs.extend(derived_refs);
+        common_refs
+    } else {
+        let mut refs = rcs.into_iter().collect::<Vec<_>>();
+        sort_register_cluster(&mut refs, sorting);
+        refs
+    }
+}