config

Author: burrbull

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- use `Config` to pass options over all render levels
 - Use register iterator from `svd-parser`
 - rm unneeded `core::convert::` prefix on `From`
 

src/generate/device.rs

@@ -4,21 +4,14 @@ use quote::{quote, ToTokens};
 use std::fs::File;
 use std::io::Write;
 
-use crate::util::{self, ToSanitizedUpperCase};
+use crate::util::{self, Config, ToSanitizedUpperCase};
 use crate::Target;
 use anyhow::Result;
 
 use crate::generate::{interrupt, peripheral};
 
 /// Whole device generation
-pub fn render(
-    d: &Device,
-    target: Target,
-    nightly: bool,
-    generic_mod: bool,
-    make_mod: bool,
-    device_x: &mut String,
-) -> Result<TokenStream> {
+pub fn render(d: &Device, config: &Config, device_x: &mut String) -> Result<TokenStream> {
     let mut out = TokenStream::new();
 
     let commit_info = {
@@ -46,14 +39,14 @@ pub fn render(
         commit_info
     );
 
-    if target == Target::Msp430 {
+    if config.target == Target::Msp430 {
         out.extend(quote! {
             #![feature(abi_msp430_interrupt)]
         });
     }
 
     out.extend(quote! { #![doc = #doc] });
-    if !make_mod {
+    if !config.make_mod {
         out.extend(quote! {
             // Deny a subset of warnings
             #![deny(const_err)]
@@ -109,7 +102,7 @@ pub fn render(
 
     let mut fields = TokenStream::new();
     let mut exprs = TokenStream::new();
-    if target == Target::CortexM {
+    if config.target == Target::CortexM {
         out.extend(quote! {
             pub use cortex_m::peripheral::Peripherals as CorePeripherals;
             #[cfg(feature = "rt")]
@@ -133,7 +126,7 @@ pub fn render(
         }
     }
 
-    if target == Target::Msp430 {
+    if config.target == Target::Msp430 {
         out.extend(quote! {
             // XXX: Are there any core peripherals, really? Requires bump of msp430 crate.
             // pub use msp430::peripheral::Peripherals as CorePeripherals;
@@ -145,10 +138,10 @@ pub fn render(
     }
 
     let generic_file = std::str::from_utf8(include_bytes!("generic.rs"))?;
-    if generic_mod {
+    if config.generic_mod {
         writeln!(File::create("generic.rs")?, "{}", generic_file)?;
 
-        if !make_mod {
+        if !config.make_mod {
             out.extend(quote! {
                 #[allow(unused_imports)]
                 use generic::*;
@@ -169,10 +162,10 @@ pub fn render(
         });
     }
 
-    out.extend(interrupt::render(target, &d.peripherals, device_x)?);
+    out.extend(interrupt::render(config.target, &d.peripherals, device_x)?);
 
     for p in &d.peripherals {
-        if target == Target::CortexM && core_peripherals.contains(&&*p.name.to_uppercase()) {
+        if config.target == Target::CortexM && core_peripherals.contains(&&*p.name.to_uppercase()) {
             // Core peripherals are handled above
             continue;
         }
@@ -181,7 +174,7 @@ pub fn render(
             p,
             &d.peripherals,
             &d.default_register_properties,
-            nightly,
+            config,
         )?);
 
         if p.registers
@@ -206,7 +199,7 @@ pub fn render(
     }
 
     let span = Span::call_site();
-    let take = match target {
+    let take = match config.target {
         Target::CortexM => Some(Ident::new("cortex_m", span)),
         Target::Msp430 => Some(Ident::new("msp430", span)),
         Target::RISCV => Some(Ident::new("riscv", span)),

src/generate/peripheral.rs

@@ -10,7 +10,9 @@ use quote::{quote, ToTokens};
 use svd_parser::derive_from::DeriveFrom;
 use syn::{parse_str, Token};
 
-use crate::util::{self, FullName, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE};
+use crate::util::{
+    self, Config, FullName, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE,
+};
 use anyhow::{anyhow, bail, Context, Result};
 
 use crate::generate::register;
@@ -19,7 +21,7 @@ pub fn render(
     p_original: &Peripheral,
     all_peripherals: &[Peripheral],
     defaults: &RegisterProperties,
-    nightly: bool,
+    config: &Config,
 ) -> Result<TokenStream> {
     let mut out = TokenStream::new();
 
@@ -177,11 +179,11 @@ pub fn render(
 
     // Push any register or cluster blocks into the output
     let mut mod_items = TokenStream::new();
-    mod_items.extend(register_or_cluster_block(&ercs, &defaults, None, nightly)?);
+    mod_items.extend(register_or_cluster_block(&ercs, &defaults, None, config)?);
 
     // Push all cluster related information into the peripheral module
     for c in &clusters {
-        mod_items.extend(cluster_block(c, &defaults, p, all_peripherals, nightly)?);
+        mod_items.extend(cluster_block(c, &defaults, p, all_peripherals, config)?);
     }
 
     // Push all register related information into the peripheral module
@@ -192,6 +194,7 @@ pub fn render(
             p,
             all_peripherals,
             &defaults,
+            config,
         )?);
     }
 
@@ -235,10 +238,7 @@ impl Region {
         let mut idents: Vec<_> = self
             .rbfs
             .iter()
-            .filter_map(|f| match &f.field.ident {
-                None => None,
-                Some(ident) => Some(ident.to_string()),
-            })
+            .filter_map(|f| f.field.ident.as_ref().map(|ident| ident.to_string()))
             .collect();
         if idents.is_empty() {
             return None;
@@ -276,10 +276,7 @@ impl Region {
         let idents: Vec<_> = self
             .rbfs
             .iter()
-            .filter_map(|f| match &f.field.ident {
-                None => None,
-                Some(ident) => Some(ident.to_string()),
-            })
+            .filter_map(|f| f.field.ident.as_ref().map(|ident| ident.to_string()))
             .collect();
 
         if idents.is_empty() {
@@ -445,7 +442,7 @@ fn register_or_cluster_block(
     ercs: &[RegisterCluster],
     defs: &RegisterProperties,
     name: Option<&str>,
-    _nightly: bool,
+    _config: &Config,
 ) -> Result<TokenStream> {
     let mut rbfs = TokenStream::new();
     let mut accessors = TokenStream::new();
@@ -738,7 +735,7 @@ fn cluster_block(
     defaults: &RegisterProperties,
     p: &Peripheral,
     all_peripherals: &[Peripheral],
-    nightly: bool,
+    config: &Config,
 ) -> Result<TokenStream> {
     let mut mod_items = TokenStream::new();
 
@@ -758,7 +755,7 @@ fn cluster_block(
 
     let defaults = c.default_register_properties.derive_from(defaults);
 
-    let reg_block = register_or_cluster_block(&c.children, &defaults, Some(&mod_name), nightly)?;
+    let reg_block = register_or_cluster_block(&c.children, &defaults, Some(&mod_name), config)?;
 
     // Generate definition for each of the registers.
     let registers = util::only_registers(&c.children);
@@ -769,13 +766,14 @@ fn cluster_block(
             p,
             all_peripherals,
             &defaults,
+            config,
         )?);
     }
 
     // Generate the sub-cluster blocks.
     let clusters = util::only_clusters(&c.children);
     for c in &clusters {
-        mod_items.extend(cluster_block(c, &defaults, p, all_peripherals, nightly)?);
+        mod_items.extend(cluster_block(c, &defaults, p, all_peripherals, config)?);
     }
 
     Ok(quote! {

src/generate/register.rs

@@ -8,7 +8,7 @@ use log::warn;
 use proc_macro2::{Ident, Punct, Spacing, Span, TokenStream};
 use quote::{quote, ToTokens};
 
-use crate::util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
+use crate::util::{self, Config, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
 use anyhow::{anyhow, Result};
 
 pub fn render(
@@ -17,6 +17,7 @@ pub fn render(
     peripheral: &Peripheral,
     all_peripherals: &[Peripheral],
     defs: &RegisterProperties,
+    config: &Config,
 ) -> Result<TokenStream> {
     let access = util::access_of(register);
     let name = util::name_of(register);
@@ -141,6 +142,7 @@ pub fn render(
                 &mut mod_items,
                 &mut r_impl_items,
                 &mut w_impl_items,
+                config,
             )?;
         }
     }
@@ -267,6 +269,7 @@ pub fn fields(
     mod_items: &mut TokenStream,
     r_impl_items: &mut TokenStream,
     w_impl_items: &mut TokenStream,
+    _config: &Config,
 ) -> Result<()> {
     let span = Span::call_site();
     let can_read = [Access::ReadOnly, Access::ReadWriteOnce, Access::ReadWrite].contains(&access);

src/lib.rs

@@ -486,7 +486,7 @@ use svd_parser as svd;
 mod generate;
 mod util;
 
-pub use crate::util::Target;
+pub use crate::util::{Config, Target};
 
 #[non_exhaustive]
 pub struct Generation {
@@ -515,8 +515,14 @@ pub fn generate(xml: &str, target: Target, nightly: bool) -> Result<Generation>
 
     let device = svd::parse(xml)?;
     let mut device_x = String::new();
-    let items = generate::device::render(&device, target, nightly, false, false, &mut device_x)
-        .or(Err(SvdError::Render))?;
+    let config = Config {
+        target,
+        nightly,
+        generic_mod: false,
+        make_mod: false,
+    };
+    let items =
+        generate::device::render(&device, &config, &mut device_x).or(Err(SvdError::Render))?;
 
     let mut lib_rs = String::new();
     writeln!(

src/main.rs

@@ -13,7 +13,7 @@ use std::process;
 use anyhow::{Context, Result};
 use clap::{App, Arg};
 
-use crate::util::{build_rs, Target};
+use crate::util::{build_rs, Config, Target};
 
 fn run() -> Result<()> {
     use std::io::Read;
@@ -99,15 +99,15 @@ fn run() -> Result<()> {
     let generic_mod = matches.is_present("generic_mod");
     let make_mod = matches.is_present("make_mod");
 
-    let mut device_x = String::new();
-    let items = generate::device::render(
-        &device,
+    let config = Config {
         target,
         nightly,
         generic_mod,
         make_mod,
-        &mut device_x,
-    )?;
+    };
+
+    let mut device_x = String::new();
+    let items = generate::device::render(&device, &config, &mut device_x)?;
     let filename = if make_mod { "mod.rs" } else { "lib.rs" };
     let mut file = File::create(filename).expect("Couldn't create output file");
 

src/util.rs

@@ -13,6 +13,15 @@ pub const BITS_PER_BYTE: u32 = 8;
 /// that are not valid in Rust ident
 const BLACKLIST_CHARS: &[char] = &['(', ')', '[', ']', '/', ' ', '-'];
 
+#[derive(Clone, Copy, PartialEq)]
+pub struct Config {
+    pub target: Target,
+    pub nightly: bool,
+    pub generic_mod: bool,
+    pub make_mod: bool,
+}
+
+#[allow(clippy::upper_case_acronyms)]
 #[allow(non_camel_case_types)]
 #[derive(Clone, Copy, PartialEq)]
 pub enum Target {