Merge #220

220: sorting on encode r=Emilgardis a=burrbull



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

Author: bors[bot]

svd-encoder/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+- Add `Sorting` options to `Config`
+
 ## [v0.14.2] - 2022-12-19
 
 - Fix typo in `headerDefinitionsPrefix`

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
     ///
@@ -150,7 +150,7 @@ where
     }
 }
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct FieldBitRangeFormat(pub BitRangeType);
 
 impl FromStr for FieldBitRangeFormat {
@@ -166,6 +166,93 @@ 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,
+}
+
+impl Sorting {
+    fn from_parts(parts: &[&str]) -> Option<Self> {
+        if parts.contains(&"Offset") {
+            Some(Self::Offset)
+        } else if parts.contains(&"OffsetReserved") {
+            Some(Self::OffsetReversed)
+        } else if parts.contains(&"Name") {
+            Some(Self::Name)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DerivableSorting {
+    Unchanged(Option<Sorting>),
+    DeriveLast(Option<Sorting>),
+}
+
+impl DerivableSorting {
+    fn from_parts(parts: &[&str]) -> Self {
+        let sorting = Sorting::from_parts(parts);
+        if parts.contains(&"DerivedLast") {
+            Self::DeriveLast(sorting)
+        } else {
+            Self::Unchanged(sorting)
+        }
+    }
+}
+
+impl FromStr for DerivableSorting {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts = s.split(',').collect::<Vec<_>>();
+        Ok(DerivableSorting::from_parts(&parts))
+    }
+}
+
+impl Default for DerivableSorting {
+    fn default() -> Self {
+        Self::Unchanged(None)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RcSorting {
+    Unchanged(DerivableSorting),
+    RegistersFirst(DerivableSorting),
+    ClustersFirst(DerivableSorting),
+}
+
+impl Default for RcSorting {
+    fn default() -> Self {
+        Self::Unchanged(Default::default())
+    }
+}
+
+impl FromStr for RcSorting {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts = s.split(',').collect::<Vec<_>>();
+        let derivable_sorting = DerivableSorting::from_parts(&parts);
+        Ok(if parts.contains(&"RegistersFirst") {
+            Self::RegistersFirst(derivable_sorting)
+        } else if parts.contains(&"ClustersFirst") {
+            Self::ClustersFirst(derivable_sorting)
+        } else {
+            Self::Unchanged(derivable_sorting)
+        })
+    }
+}
+
 #[derive(Clone, Copy, Debug)]
 #[non_exhaustive]
 /// Advanced encoder options
@@ -184,6 +271,9 @@ pub struct Config {
     /// format: hex, dec
     pub peripheral_base_address: NumberFormat,
 
+    /// Sort peripherals in specified order
+    pub peripheral_sorting: DerivableSorting,
+
     /// Format of addressBlock's offset element
     ///
     /// format: hex, dec
@@ -209,6 +299,9 @@ pub struct Config {
     /// format: hex, dec
     pub cluster_address_offset: NumberFormat,
 
+    /// Sort registers and clusters in specified order
+    pub register_cluster_sorting: RcSorting,
+
     /// Format of register's name-kind elements
     /// - `derivedFrom`
     /// - `name`
@@ -245,6 +338,9 @@ pub struct Config {
     /// `None` means keep the original bitRange
     pub field_bit_range: Option<FieldBitRangeFormat>,
 
+    /// Sort fields in specified order
+    pub field_sorting: DerivableSorting,
+
     /// Format of enumeratedValues's name-kind elements
     /// - `derivedFrom`
     /// - `name`
@@ -278,18 +374,21 @@ impl Default for Config {
         Self {
             peripheral_name: None,
             peripheral_base_address: NumberFormat::UpperHex8,
+            peripheral_sorting: Default::default(),
             address_block_offset: NumberFormat::UpperHex,
             address_block_size: NumberFormat::UpperHex,
             interrupt_name: None,
             cluster_name: None,
             cluster_address_offset: NumberFormat::UpperHex,
+            register_cluster_sorting: Default::default(),
             register_name: None,
             register_address_offset: NumberFormat::UpperHex,
             register_size: NumberFormat::LowerHex,
             register_reset_value: NumberFormat::UpperHex16,
             register_reset_mask: NumberFormat::UpperHex16,
             field_name: None,
             field_bit_range: None,
+            field_sorting: Default::default(),
             enumerated_values_name: None,
             enumerated_value_name: None,
             enumerated_value_value: NumberFormat::Dec,
@@ -308,18 +407,21 @@ impl Config {
         match name {
             "peripheral_name" => self.peripheral_name = Some(value.parse().unwrap()),
             "peripheral_base_address" => self.peripheral_base_address = value.parse().unwrap(),
+            "peripheral_sorting" => self.peripheral_sorting = 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()),
             "cluster_name" => self.cluster_name = Some(value.parse().unwrap()),
             "cluster_address_offset" => self.cluster_address_offset = value.parse().unwrap(),
+            "register_cluster_sorting" => self.register_cluster_sorting = 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(),
             "register_reset_value" => self.register_reset_value = value.parse().unwrap(),
             "register_reset_mask" => self.register_reset_mask = value.parse().unwrap(),
             "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 = 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(),
@@ -348,6 +450,14 @@ impl Config {
         self
     }
 
+    /// Sort peripherals in specified order
+    ///
+    /// `None` means keep the original order
+    pub fn peripheral_sorting(mut self, val: DerivableSorting) -> Self {
+        self.peripheral_sorting = val;
+        self
+    }
+
     /// Format of addressBlock's offset element
     ///
     /// format: hex, dec
@@ -384,6 +494,14 @@ impl Config {
         self
     }
 
+    /// Sort registers and clusters in specified order
+    ///
+    /// `None` means keep the original order
+    pub fn register_cluster_sorting(mut self, val: RcSorting) -> Self {
+        self.register_cluster_sorting = val;
+        self
+    }
+
     /// Format of register's name-kind elements
     pub fn register_name(mut self, val: Option<IdentifierFormat>) -> Self {
         self.register_name = val;
@@ -436,6 +554,14 @@ impl Config {
         self
     }
 
+    /// Sort fields in specified order
+    ///
+    /// `None` means keep the original order
+    pub fn field_sorting(mut self, val: DerivableSorting) -> Self {
+        self.field_sorting = 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,5 +1,10 @@
+use svd_rs::Peripheral;
+
 use super::{new_node, Config, Element, Encode, EncodeChildren, EncodeError, XMLNode};
-use crate::svd::Device;
+use crate::{
+    config::{DerivableSorting, Sorting},
+    svd::Device,
+};
 
 impl Encode for Device {
     type Error = EncodeError;
@@ -57,11 +62,19 @@ impl Encode for Device {
                 .encode_with_config(config)?,
         );
 
-        let peripherals: Result<Vec<_>, _> = self
-            .peripherals
-            .iter()
-            .map(|peripheral| peripheral.encode_node_with_config(config))
-            .collect();
+        let peripherals: Result<Vec<_>, _> =
+            if config.peripheral_sorting == DerivableSorting::Unchanged(None) {
+                self.peripherals
+                    .iter()
+                    .map(|peripheral| peripheral.encode_node_with_config(config))
+                    .collect()
+            } else {
+                sort_derived_peripherals(&self.peripherals, config.peripheral_sorting)
+                    .into_iter()
+                    .map(|peripheral| peripheral.encode_node_with_config(config))
+                    .collect()
+            };
+
         elem.children.push({
             let mut e = Element::new("peripherals");
             e.children = peripherals?;
@@ -80,3 +93,42 @@ 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: DerivableSorting,
+) -> Vec<&Peripheral> {
+    match sorting {
+        DerivableSorting::Unchanged(sorting) => {
+            let mut refs = peripherals.iter().collect::<Vec<_>>();
+            sort_peripherals(&mut refs, sorting);
+            refs
+        }
+        DerivableSorting::DeriveLast(sorting) => {
+            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
+        }
+    }
+}

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};
+pub use crate::config::{
+    Config, DerivableSorting, IdentifierFormat, NumberFormat, RcSorting, Sorting,
+};
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum EncodeError {}