add --ignore_groups

Author: burrbull

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- option `ignore_groups` for optional disabling #506
 - [breaking-change] move `const_generic` from features to options
 - use `Config` to pass options over all render levels
 - Use register iterator from `svd-parser`

src/generate/peripheral.rs

@@ -442,13 +442,13 @@ fn register_or_cluster_block(
     ercs: &[RegisterCluster],
     defs: &RegisterProperties,
     name: Option<&str>,
-    _config: &Config,
+    config: &Config,
 ) -> Result<TokenStream> {
     let mut rbfs = TokenStream::new();
     let mut accessors = TokenStream::new();
     let mut have_accessors = false;
 
-    let ercs_expanded = expand(ercs, defs, name)?;
+    let ercs_expanded = expand(ercs, defs, name, config)?;
 
     // Locate conflicting regions; we'll need to use unions to represent them.
     let mut regions = FieldRegions::default();
@@ -576,13 +576,14 @@ fn expand(
     ercs: &[RegisterCluster],
     defs: &RegisterProperties,
     name: Option<&str>,
+    config: &Config,
 ) -> Result<Vec<RegisterBlockField>> {
     let mut ercs_expanded = vec![];
 
     for erc in ercs {
         ercs_expanded.extend(match &erc {
-            RegisterCluster::Register(register) => expand_register(register, defs, name)?,
-            RegisterCluster::Cluster(cluster) => expand_cluster(cluster, defs, name)?,
+            RegisterCluster::Register(register) => expand_register(register, defs, name, config)?,
+            RegisterCluster::Cluster(cluster) => expand_cluster(cluster, defs, name, config)?,
         });
     }
 
@@ -593,21 +594,25 @@ fn expand(
 
 /// Recursively calculate the size of a cluster. A cluster's size is the maximum
 /// end position of its recursive children.
-fn cluster_size_in_bits(info: &ClusterInfo, defs: &RegisterProperties) -> Result<u32> {
+fn cluster_size_in_bits(
+    info: &ClusterInfo,
+    defs: &RegisterProperties,
+    config: &Config,
+) -> Result<u32> {
     let mut size = 0;
 
     for c in &info.children {
         let end = match c {
             RegisterCluster::Register(reg) => {
-                let reg_size: u32 = expand_register(reg, defs, None)?
+                let reg_size: u32 = expand_register(reg, defs, None, config)?
                     .iter()
                     .map(|rbf| rbf.size)
                     .sum();
 
                 (reg.address_offset * BITS_PER_BYTE) + reg_size
             }
             RegisterCluster::Cluster(clust) => {
-                (clust.address_offset * BITS_PER_BYTE) + cluster_size_in_bits(clust, defs)?
+                (clust.address_offset * BITS_PER_BYTE) + cluster_size_in_bits(clust, defs, config)?
             }
         };
 
@@ -621,12 +626,13 @@ fn expand_cluster(
     cluster: &Cluster,
     defs: &RegisterProperties,
     name: Option<&str>,
+    config: &Config,
 ) -> Result<Vec<RegisterBlockField>> {
     let mut cluster_expanded = vec![];
 
     let defs = cluster.default_register_properties.derive_from(defs);
 
-    let cluster_size = cluster_size_in_bits(cluster, &defs)
+    let cluster_size = cluster_size_in_bits(cluster, &defs, config)
         .with_context(|| format!("Cluster {} has no determinable `size` field", cluster.name))?;
 
     match cluster {
@@ -678,6 +684,7 @@ fn expand_register(
     register: &Register,
     defs: &RegisterProperties,
     name: Option<&str>,
+    config: &Config,
 ) -> Result<Vec<RegisterBlockField>> {
     let mut register_expanded = vec![];
 
@@ -688,7 +695,7 @@ fn expand_register(
 
     match register {
         Register::Single(info) => register_expanded.push(RegisterBlockField {
-            field: convert_svd_register(register, name)?,
+            field: convert_svd_register(register, name, config.ignore_groups)?,
             description: info.description.clone().unwrap_or_default(),
             offset: info.address_offset,
             size: register_size,
@@ -708,13 +715,16 @@ fn expand_register(
 
             if array_convertible {
                 register_expanded.push(RegisterBlockField {
-                    field: convert_svd_register(&register, name)?,
+                    field: convert_svd_register(&register, name, config.ignore_groups)?,
                     description: info.description.clone().unwrap_or_default(),
                     offset: info.address_offset,
                     size: register_size * array_info.dim,
                 });
             } else {
-                for (field_num, field) in expand_svd_register(register, name)?.iter().enumerate() {
+                for (field_num, field) in expand_svd_register(register, name, config.ignore_groups)?
+                    .iter()
+                    .enumerate()
+                {
                     register_expanded.push(RegisterBlockField {
                         field: field.clone(),
                         description: info.description.clone().unwrap_or_default(),
@@ -792,11 +802,12 @@ fn cluster_block(
 fn expand_svd_register(
     register: &Register,
     name: Option<&str>,
+    ignore_group: bool,
 ) -> Result<Vec<syn::Field>, syn::Error> {
     let mut out = vec![];
 
     match register {
-        Register::Single(_info) => out.push(convert_svd_register(register, name)?),
+        Register::Single(_info) => out.push(convert_svd_register(register, name, ignore_group)?),
         Register::Array(info, array_info) => {
             let indices = array_info
                 .dim_index
@@ -810,10 +821,10 @@ fn expand_svd_register(
                     )
                 });
 
-            let ty_name = util::replace_suffix(&info.fullname(), "");
+            let ty_name = util::replace_suffix(&info.fullname(ignore_group), "");
 
             for (idx, _i) in indices.iter().zip(0..) {
-                let nb_name = util::replace_suffix(&info.fullname(), idx);
+                let nb_name = util::replace_suffix(&info.fullname(ignore_group), idx);
 
                 let ty = name_to_wrapped_ty(&ty_name, name)?;
 
@@ -825,17 +836,21 @@ fn expand_svd_register(
 }
 
 /// Convert a parsed `Register` into its `Field` equivalent
-fn convert_svd_register(register: &Register, name: Option<&str>) -> Result<syn::Field, syn::Error> {
+fn convert_svd_register(
+    register: &Register,
+    name: Option<&str>,
+    ignore_group: bool,
+) -> Result<syn::Field, syn::Error> {
     Ok(match register {
         Register::Single(info) => {
-            let info_name = info.fullname();
+            let info_name = info.fullname(ignore_group);
             new_syn_field(
                 &info_name.to_sanitized_snake_case(),
                 name_to_wrapped_ty(&info_name, name)?,
             )
         }
         Register::Array(info, array_info) => {
-            let nb_name = util::replace_suffix(&info.fullname(), "");
+            let nb_name = util::replace_suffix(&info.fullname(ignore_group), "");
             let ty = syn::Type::Array(parse_str::<syn::TypeArray>(&format!(
                 "[{};{}]",
                 name_to_wrapped_ty_str(&nb_name, name),

src/generate/register.rs

@@ -20,7 +20,7 @@ pub fn render(
     config: &Config,
 ) -> Result<TokenStream> {
     let access = util::access_of(register);
-    let name = util::name_of(register);
+    let name = util::name_of(register, config.ignore_groups);
     let span = Span::call_site();
     let name_pc = Ident::new(&name.to_sanitized_upper_case(), span);
     let name_uc_spec = Ident::new(&format!("{}_SPEC", &name.to_sanitized_upper_case()), span);

src/main.rs

@@ -43,6 +43,11 @@ fn run() -> Result<()> {
             .arg(Arg::with_name("const_generic").long("const_generic").help(
                 "Use const generics to generate writers for same fields with different offsets",
             ))
+            .arg(
+                Arg::with_name("ignore_groups")
+                    .long("ignore_groups")
+                    .help("Don't add alternateGroup name as prefix to register name"),
+            )
             .arg(
                 Arg::with_name("generic_mod")
                     .long("generic_mod")
@@ -106,6 +111,7 @@ fn run() -> Result<()> {
         generic_mod: matches.is_present("generic_mod"),
         make_mod,
         const_generic: matches.is_present("const_generic"),
+        ignore_groups: matches.is_present("ignore_groups"),
     };
 
     let mut device_x = String::new();

src/util.rs

@@ -20,6 +20,7 @@ pub struct Config {
     pub generic_mod: bool,
     pub make_mod: bool,
     pub const_generic: bool,
+    pub ignore_groups: bool,
 }
 
 #[allow(clippy::upper_case_acronyms)]
@@ -154,10 +155,10 @@ pub fn escape_brackets(s: &str) -> String {
         })
 }
 
-pub fn name_of(register: &Register) -> Cow<str> {
+pub fn name_of(register: &Register, ignore_group: bool) -> Cow<str> {
     match register {
-        Register::Single(info) => info.fullname(),
-        Register::Array(info, _) => replace_suffix(&info.fullname(), "").into(),
+        Register::Single(info) => info.fullname(ignore_group),
+        Register::Array(info, _) => replace_suffix(&info.fullname(ignore_group), "").into(),
     }
 }
 
@@ -343,15 +344,14 @@ pub fn build_rs() -> TokenStream {
 }
 
 pub trait FullName {
-    fn fullname(&self) -> Cow<str>;
+    fn fullname(&self, ignore_group: bool) -> Cow<str>;
 }
 
 impl FullName for RegisterInfo {
-    fn fullname(&self) -> Cow<str> {
-        if let Some(group) = &self.alternate_group {
-            format!("{}_{}", group, self.name).into()
-        } else {
-            self.name.as_str().into()
+    fn fullname(&self, ignore_group: bool) -> Cow<str> {
+        match &self.alternate_group {
+            Some(group) if !ignore_group => format!("{}_{}", group, self.name).into(),
+            _ => self.name.as_str().into(),
         }
     }
 }