feat: add argument feature_group

- When off, do nothing else
- When on
  - generate cfg attribute for every `groupName`
  - generate `features.toml` containing all `groupName`

close #614

Author: duskmoon314

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+- Add new feature `feature_group` which will generate cfg attribute for
+  every group name when it is on
+
 ## [v0.24.1] - 2022-07-04
 
 - Make field writer always generic around bit offset (fix bug #620)

src/generate/device.rs

@@ -1,5 +1,5 @@
 use crate::svd::{array::names, Device, Peripheral};
-use crate::util::U32Ext;
+use crate::util::{ToSanitizedSnakeCase, U32Ext};
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 
@@ -204,7 +204,12 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
     }
 
     debug!("Rendering interrupts");
-    out.extend(interrupt::render(config.target, &d.peripherals, device_x)?);
+    out.extend(interrupt::render(
+        config.target,
+        &d.peripherals,
+        device_x,
+        config,
+    )?);
 
     for p in &d.peripherals {
         if config.target == Target::CortexM && core_peripherals.contains(&&*p.name.to_uppercase()) {
@@ -246,6 +251,12 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
             // in the `Peripherals` struct
             continue;
         }
+        let feature_attribute = if config.feature_group && p.group_name.is_some() {
+            let feature_name = p.group_name.as_ref().unwrap().to_sanitized_snake_case();
+            quote!(#[cfg(feature = #feature_name)])
+        } else {
+            quote!()
+        };
 
         match p {
             Peripheral::Single(_p) => {
@@ -254,9 +265,10 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                 let id = Ident::new(&p, Span::call_site());
                 fields.extend(quote! {
                     #[doc = #p]
+                    #feature_attribute
                     pub #id: #id,
                 });
-                exprs.extend(quote!(#id: #id { _marker: PhantomData },));
+                exprs.extend(quote!(#feature_attribute #id: #id { _marker: PhantomData },));
             }
             Peripheral::Array(_p, dim_element) => {
                 let p_names: Vec<Cow<str>> = names(p, dim_element).map(|n| n.into()).collect();
@@ -266,10 +278,13 @@ pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<Toke
                 fields.extend(quote! {
                     #(
                         #[doc = #p]
+                        #feature_attribute
                         pub #ids_f: #ids_f,
                     )*
                 });
-                exprs.extend(quote!(#(#ids_e: #ids_e { _marker: PhantomData },)*));
+                exprs.extend(
+                    quote!(#(#feature_attribute #ids_e: #ids_e { _marker: PhantomData },)*),
+                );
             }
         }
     }

src/generate/interrupt.rs

@@ -6,67 +6,98 @@ use cast::u64;
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 
-use crate::util::{self, ToSanitizedUpperCase};
-use crate::Target;
+use crate::util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase};
+use crate::{Config, Target};
 use anyhow::Result;
 
 /// Generates code for `src/interrupt.rs`
 pub fn render(
     target: Target,
     peripherals: &[Peripheral],
     device_x: &mut String,
+    config: &Config,
 ) -> Result<TokenStream> {
     let interrupts = peripherals
         .iter()
-        .flat_map(|p| p.interrupt.iter())
-        .map(|i| (i.value, i))
+        .flat_map(|p| p.interrupt.iter().map(move |i| (i, p.group_name.clone())))
+        .map(|i| (i.0.value, (i.0, i.1)))
         .collect::<HashMap<_, _>>();
 
     let mut interrupts = interrupts.into_iter().map(|(_, v)| v).collect::<Vec<_>>();
-    interrupts.sort_by_key(|i| i.value);
+    interrupts.sort_by_key(|i| i.0.value);
 
     let mut root = TokenStream::new();
     let mut from_arms = TokenStream::new();
     let mut elements = TokenStream::new();
     let mut names = vec![];
+    let mut names_cfg_attr = vec![];
     let mut variants = TokenStream::new();
 
     // Current position in the vector table
     let mut pos = 0;
     let mut mod_items = TokenStream::new();
     for interrupt in &interrupts {
-        while pos < interrupt.value {
+        while pos < interrupt.0.value {
             elements.extend(quote!(Vector { _reserved: 0 },));
             pos += 1;
         }
         pos += 1;
 
-        let name_uc = Ident::new(&interrupt.name.to_sanitized_upper_case(), Span::call_site());
+        let name_uc = Ident::new(
+            &interrupt.0.name.to_sanitized_upper_case(),
+            Span::call_site(),
+        );
         let description = format!(
             "{} - {}",
-            interrupt.value,
+            interrupt.0.value,
             interrupt
+                .0
                 .description
                 .as_ref()
                 .map(|s| util::respace(s))
                 .as_ref()
                 .map(|s| util::escape_brackets(s))
-                .unwrap_or_else(|| interrupt.name.clone())
+                .unwrap_or_else(|| interrupt.0.name.clone())
         );
 
-        let value = util::unsuffixed(u64(interrupt.value));
+        let value = util::unsuffixed(u64(interrupt.0.value));
+
+        let mut feature_attribute_flag = false;
+        let (feature_attribute, not_feature_attribute) =
+            if config.feature_group && interrupt.1.is_some() {
+                let feature_name = interrupt.1.as_ref().unwrap().to_sanitized_snake_case();
+                feature_attribute_flag = true;
+                (
+                    quote!(#[cfg(feature = #feature_name)]),
+                    quote!(#[cfg(not(feature = #feature_name))]),
+                )
+            } else {
+                (quote!(), quote!())
+            };
 
         variants.extend(quote! {
             #[doc = #description]
+            #feature_attribute
             #name_uc = #value,
         });
 
         from_arms.extend(quote! {
+            #feature_attribute
             #value => Ok(Interrupt::#name_uc),
         });
 
-        elements.extend(quote!(Vector { _handler: #name_uc },));
+        if feature_attribute_flag {
+            elements.extend(quote! {
+                #not_feature_attribute
+                Vector { _reserved: 0 },
+                #feature_attribute
+                Vector { _handler: #name_uc },
+            });
+        } else {
+            elements.extend(quote!(Vector { _handler: #name_uc },));
+        }
         names.push(name_uc);
+        names_cfg_attr.push(feature_attribute);
     }
 
     let n = util::unsuffixed(u64(pos));
@@ -79,7 +110,7 @@ pub fn render(
             root.extend(quote! {
                 #[cfg(feature = "rt")]
                 extern "C" {
-                    #(fn #names();)*
+                    #(#names_cfg_attr fn #names();)*
                 }
 
                 #[doc(hidden)]
@@ -105,7 +136,7 @@ pub fn render(
             root.extend(quote! {
                 #[cfg(feature = "rt")]
                 extern "msp430-interrupt" {
-                    #(fn #names();)*
+                    #(#names_cfg_attr fn #names();)*
                 }
 
                 #[doc(hidden)]
@@ -133,7 +164,7 @@ pub fn render(
             root.extend(quote! {
                 #[cfg(feature = "rt")]
                 extern "C" {
-                    #(fn #names();)*
+                    #(#names_cfg_attr fn #names();)*
                 }
 
                 #[doc(hidden)]
@@ -158,7 +189,7 @@ pub fn render(
             root.extend(quote! {
                 #[cfg(feature = "rt")]
                 extern "C" {
-                    #(fn #names();)*
+                    #(#names_cfg_attr fn #names();)*
                 }
 
                 #[doc(hidden)]

src/generate/peripheral.rs

@@ -56,6 +56,13 @@ pub fn render(
         (false, name_sc.clone())
     };
 
+    let feature_attribute = if config.feature_group && p.group_name.is_some() {
+        let feature_name = p.group_name.as_ref().unwrap().to_sanitized_snake_case();
+        quote! (#[cfg(feature = #feature_name)])
+    } else {
+        quote! {}
+    };
+
     match p_original {
         Peripheral::Array(p, dim) => {
             let names: Vec<Cow<str>> = names(p, dim).map(|n| n.into()).collect();
@@ -68,10 +75,13 @@ pub fn render(
             out.extend(quote! {
                 #(
                     #[doc = #description]
+                    #feature_attribute
                     pub struct #names_pc { _marker: PhantomData<*const ()> }
 
+                    #feature_attribute
                     unsafe impl Send for #names_pc {}
 
+                    #feature_attribute
                     impl #names_pc {
                         ///Pointer to the register block
                         pub const PTR: *const #base::RegisterBlock = #addresses as *const _;
@@ -83,6 +93,7 @@ pub fn render(
                         }
                     }
 
+                    #feature_attribute
                     impl Deref for #names_pc {
                         type Target = #base::RegisterBlock;
 
@@ -92,6 +103,7 @@ pub fn render(
                         }
                     }
 
+                    #feature_attribute
                     impl core::fmt::Debug for #names_pc {
                         fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                             f.debug_struct(#names_str).finish()
@@ -104,10 +116,13 @@ pub fn render(
             // Insert the peripheral structure
             out.extend(quote! {
                 #[doc = #description]
+                #feature_attribute
                 pub struct #name_pc { _marker: PhantomData<*const ()> }
 
+                #feature_attribute
                 unsafe impl Send for #name_pc {}
 
+                #feature_attribute
                 impl #name_pc {
                     ///Pointer to the register block
                     pub const PTR: *const #base::RegisterBlock = #address as *const _;
@@ -119,6 +134,7 @@ pub fn render(
                     }
                 }
 
+                #feature_attribute
                 impl Deref for #name_pc {
                     type Target = #base::RegisterBlock;
 
@@ -128,6 +144,7 @@ pub fn render(
                     }
                 }
 
+                #feature_attribute
                 impl core::fmt::Debug for #name_pc {
                     fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                         f.debug_struct(#name_str).finish()
@@ -143,6 +160,7 @@ pub fn render(
         // re-export the base module to allow deriveFrom this one
         out.extend(quote! {
             #[doc = #description]
+            #feature_attribute
             pub use #base as #name_sc;
         });
         return Ok(out);
@@ -216,6 +234,7 @@ pub fn render(
 
     out.extend(quote! {
         #[doc = #description]
+        #feature_attribute
         pub mod #name_sc #open
     });
 

src/main.rs

@@ -12,7 +12,7 @@ use clap::{App, Arg};
 
 use svd2rust::{
     generate, load_from,
-    util::{build_rs, Config, SourceType, Target},
+    util::{build_rs, group_names, Config, SourceType, Target},
 };
 
 fn run() -> Result<()> {
@@ -75,6 +75,11 @@ fn run() -> Result<()> {
                 .short("g")
                 .help("Push generic mod in separate file"),
         )
+        .arg(
+            Arg::with_name("feature_group")
+                .long("feature_group")
+                .help("Use group_name of peripherals as feature"),
+        )
         .arg(
             Arg::with_name("make_mod")
                 .long("make_mod")
@@ -169,6 +174,8 @@ fn run() -> Result<()> {
         || cfg.bool_flag("pascal_enum_values", Filter::Conf);
     let derive_more =
         cfg.bool_flag("derive_more", Filter::Arg) || cfg.bool_flag("derive_more", Filter::Conf);
+    let feature_group =
+        cfg.bool_flag("feature_group", Filter::Arg) || cfg.bool_flag("feature_group", Filter::Conf);
 
     let mut source_type = cfg
         .grab()
@@ -193,6 +200,7 @@ fn run() -> Result<()> {
         strict,
         pascal_enum_values,
         derive_more,
+        feature_group,
         output_dir: path.clone(),
         source_type,
     };
@@ -221,6 +229,21 @@ fn run() -> Result<()> {
         writeln!(File::create(path.join("build.rs"))?, "{}", build_rs())?;
     }
 
+    if feature_group {
+        let group_names: Vec<String> = group_names(&device)
+            .iter()
+            .map(|s| format!("{} = []\n", s))
+            .collect();
+        write!(
+            File::create(path.join("features.toml"))?,
+            "# Below are the FEATURES generated by svd2rust base on groupName in SVD file.\n\
+            # Please copy them to Cargo.toml.\n\
+            [features]\n\
+            {}",
+            group_names.join("")
+        )?;
+    }
+
     Ok(())
 }
 

src/util.rs

@@ -30,6 +30,7 @@ pub struct Config {
     pub strict: bool,
     pub pascal_enum_values: bool,
     pub derive_more: bool,
+    pub feature_group: bool,
     pub output_dir: PathBuf,
     pub source_type: SourceType,
 }
@@ -47,6 +48,7 @@ impl Default for Config {
             strict: false,
             pascal_enum_values: false,
             derive_more: false,
+            feature_group: false,
             output_dir: PathBuf::from("."),
             source_type: SourceType::default(),
         }
@@ -482,3 +484,11 @@ impl FullName for PeripheralInfo {
         self.name.as_str().into()
     }
 }
+
+pub fn group_names(d: &Device) -> HashSet<Cow<str>> {
+    d.peripherals
+        .iter()
+        .filter_map(|p| p.group_name.as_ref())
+        .map(|name| name.to_sanitized_snake_case())
+        .collect()
+}