merge config options

Author: burrbull

svd-encoder/src/config.rs

@@ -178,34 +178,78 @@ pub enum Sorting {
     Name,
 }
 
-impl FromStr for Sorting {
+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> {
-        match s {
-            "Offset" => Ok(Self::Offset),
-            "OffsetReversed" => Ok(Self::OffsetReversed),
-            "Name" => Ok(Self::OffsetReversed),
-            _ => 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 RegistersOrClustersFirst {
-    Registers,
-    Clusters,
+pub enum RcSorting {
+    Unchanged(DerivableSorting),
+    RegistersFirst(DerivableSorting),
+    ClustersFirst(DerivableSorting),
 }
 
-impl FromStr for RegistersOrClustersFirst {
+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> {
-        match s {
-            "Registers" => Ok(Self::Registers),
-            "Clusters" => Ok(Self::Clusters),
-            _ => 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)
+        })
     }
 }
 
@@ -228,10 +272,7 @@ pub struct Config {
     pub peripheral_base_address: NumberFormat,
 
     /// Sort peripherals in specified order
-    pub peripheral_sorting: Option<Sorting>,
-
-    /// Place derived peripherals in the end
-    pub peripheral_derived_last: bool,
+    pub peripheral_sorting: DerivableSorting,
 
     /// Format of addressBlock's offset element
     ///
@@ -259,13 +300,7 @@ pub struct Config {
     pub cluster_address_offset: NumberFormat,
 
     /// 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>,
-
-    /// Place derived registers and clusters in the end
-    pub register_cluster_derived_last: bool,
+    pub register_cluster_sorting: RcSorting,
 
     /// Format of register's name-kind elements
     /// - `derivedFrom`
@@ -304,10 +339,7 @@ pub struct Config {
     pub field_bit_range: Option<FieldBitRangeFormat>,
 
     /// Sort fields in specified order
-    pub field_sorting: Option<Sorting>,
-
-    /// Place derived fields in the end
-    pub field_derived_last: bool,
+    pub field_sorting: DerivableSorting,
 
     /// Format of enumeratedValues's name-kind elements
     /// - `derivedFrom`
@@ -342,25 +374,21 @@ impl Default for Config {
         Self {
             peripheral_name: None,
             peripheral_base_address: NumberFormat::UpperHex8,
-            peripheral_sorting: None,
-            peripheral_derived_last: false,
+            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: None,
-            registers_or_clusters_first: None,
-            register_cluster_derived_last: false,
+            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: None,
-            field_derived_last: false,
+            field_sorting: Default::default(),
             enumerated_values_name: None,
             enumerated_value_name: None,
             enumerated_value_value: NumberFormat::Dec,
@@ -379,31 +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 = Some(value.parse().unwrap()),
-            "peripheral_derived_last" => self.peripheral_derived_last = 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 = Some(value.parse().unwrap())
-            }
-            "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_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 = Some(value.parse().unwrap()),
-            "field_derived_last" => self.field_derived_last = 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(),
@@ -435,19 +453,11 @@ impl Config {
     /// Sort peripherals in specified order
     ///
     /// `None` means keep the original order
-    pub fn peripheral_sorting(mut self, val: Option<Sorting>) -> Self {
+    pub fn peripheral_sorting(mut self, val: DerivableSorting) -> Self {
         self.peripheral_sorting = val;
         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
@@ -487,27 +497,11 @@ impl Config {
     /// Sort registers and clusters in specified order
     ///
     /// `None` means keep the original order
-    pub fn register_cluster_sorting(mut self, val: Option<Sorting>) -> Self {
+    pub fn register_cluster_sorting(mut self, val: RcSorting) -> Self {
         self.register_cluster_sorting = val;
         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
-    }
-
-    /// 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;
@@ -563,19 +557,11 @@ impl Config {
     /// Sort fields in specified order
     ///
     /// `None` means keep the original order
-    pub fn field_sorting(mut self, val: Option<Sorting>) -> Self {
+    pub fn field_sorting(mut self, val: DerivableSorting) -> Self {
         self.field_sorting = val;
         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,7 +1,10 @@
 use svd_rs::Peripheral;
 
 use super::{new_node, Config, Element, Encode, EncodeChildren, EncodeError, XMLNode};
-use crate::{config::Sorting, svd::Device};
+use crate::{
+    config::{DerivableSorting, Sorting},
+    svd::Device,
+};
 
 impl Encode for Device {
     type Error = EncodeError;
@@ -60,20 +63,16 @@ impl Encode for Device {
         );
 
         let peripherals: Result<Vec<_>, _> =
-            if !config.peripheral_derived_last && config.peripheral_sorting.is_none() {
+            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,
-                    config.peripheral_derived_last,
-                )
-                .into_iter()
-                .map(|peripheral| peripheral.encode_node_with_config(config))
-                .collect()
+                sort_derived_peripherals(&self.peripherals, config.peripheral_sorting)
+                    .into_iter()
+                    .map(|peripheral| peripheral.encode_node_with_config(config))
+                    .collect()
             };
 
         elem.children.push({
@@ -109,25 +108,27 @@ fn sort_peripherals(refs: &mut [&Peripheral], sorting: Option<Sorting>) {
 
 fn sort_derived_peripherals(
     peripherals: &[Peripheral],
-    sorting: Option<Sorting>,
-    derived_last: bool,
+    sorting: DerivableSorting,
 ) -> 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
+    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

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