Cargo fmt

Author: jamesmunns

src/generate/device.rs

@@ -1,4 +1,4 @@
-use quote::{Tokens};
+use quote::Tokens;
 use svd::Device;
 use syn::Ident;
 
@@ -85,18 +85,7 @@ pub fn render(d: &Device, target: &Target) -> Result<Vec<Tokens>> {
     out.extend(interrupt::render(d, target, &d.peripherals)?);
 
     const CORE_PERIPHERALS: &[&str] = &[
-        "CBP",
-        "CPUID",
-        "DCB",
-        "DWT",
-        "FPB",
-        "FPU",
-        "ITM",
-        "MPU",
-        "NVIC",
-        "SCB",
-        "SYST",
-        "TPIU",
+        "CBP", "CPUID", "DCB", "DWT", "FPB", "FPU", "ITM", "MPU", "NVIC", "SCB", "SYST", "TPIU"
     ];
 
     let mut fields = vec![];
@@ -153,17 +142,19 @@ pub fn render(d: &Device, target: &Target) -> Result<Vec<Tokens>> {
         Target::CortexM => Some(Ident::new("cortex_m")),
         Target::Msp430 => Some(Ident::new("msp430")),
         Target::None => None,
-    }.map(|krate| quote! {
-        /// Returns all the peripherals *once*
-        #[inline]
-        pub fn take() -> Option<Self> {
-            #krate::interrupt::free(|_| {
-                if unsafe { DEVICE_PERIPHERALS } {
-                    None
-                } else {
-                    Some(unsafe { Peripherals::steal() })
-                }
-            })
+    }.map(|krate| {
+        quote! {
+            /// Returns all the peripherals *once*
+            #[inline]
+            pub fn take() -> Option<Self> {
+                #krate::interrupt::free(|_| {
+                    if unsafe { DEVICE_PERIPHERALS } {
+                        None
+                    } else {
+                        Some(unsafe { Peripherals::steal() })
+                    }
+                })
+            }
         }
     });
 

src/generate/interrupt.rs

@@ -10,11 +10,7 @@ use util::{self, ToSanitizedUpperCase};
 use Target;
 
 /// Generates code for `src/interrupt.rs`
-pub fn render(
-    device: &Device,
-    target: &Target,
-    peripherals: &[Peripheral],
-) -> Result<Vec<Tokens>> {
+pub fn render(device: &Device, target: &Target, peripherals: &[Peripheral]) -> Result<Vec<Tokens>> {
     let interrupts = peripherals
         .iter()
         .flat_map(|p| p.interrupt.iter())

src/generate/peripheral.rs

@@ -8,7 +8,6 @@ use syn::{self, Ident};
 use errors::*;
 use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, BITS_PER_BYTE};
 
-
 use generate::register;
 
 pub fn render(
@@ -76,7 +75,7 @@ pub fn render(
             registers,
             p,
             all_peripherals,
-            defaults
+            defaults,
         )?);
     }
 
@@ -124,7 +123,8 @@ fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
                 size: register_size,
             }),
             Register::Array(ref info, ref array_info) => {
-                let sequential_addresses = register_size == array_info.dim_increment * BITS_PER_BYTE;
+                let sequential_addresses =
+                    register_size == array_info.dim_increment * BITS_PER_BYTE;
 
                 // if dimIndex exists, test if it is a sequence of numbers from 0 to dim
                 let sequential_indexes = array_info.dim_index.as_ref().map_or(true, |dim_index| {
@@ -209,7 +209,6 @@ fn register_block(registers: &[Register], defs: &Defaults) -> Result<Tokens> {
     })
 }
 
-
 /// Takes a svd::Register which may be a register array, and turn in into
 /// a list of syn::Field where the register arrays have been expanded.
 fn expand_svd_register(register: &Register) -> Vec<syn::Field> {

src/generate/register.rs

@@ -1,13 +1,12 @@
 use cast::u64;
 use quote::Tokens;
-use svd::{Access, BitRange, Defaults, EnumeratedValues, Field, Peripheral, Register,
-          Usage, WriteConstraint};
+use svd::{Access, BitRange, Defaults, EnumeratedValues, Field, Peripheral, Register, Usage,
+          WriteConstraint};
 use syn::Ident;
 
 use errors::*;
 use util::{self, ToSanitizedSnakeCase, ToSanitizedUpperCase, U32Ext};
 
-
 pub fn render(
     register: &Register,
     all_registers: &[Register],
@@ -714,7 +713,6 @@ pub fn fields(
                     });
                 }
 
-
                 proxy_items.push(quote! {
                     /// Writes `variant` to the field
                     #[inline]
@@ -840,37 +838,42 @@ fn lookup<'a>(
     usage: Usage,
 ) -> Result<Option<(&'a EnumeratedValues, Option<Base<'a>>)>> {
     let evs = evs.iter()
-        .map(|evs| if let Some(ref base) = evs.derived_from {
-            let mut parts = base.split('.');
-
-            match (parts.next(), parts.next(), parts.next(), parts.next()) {
-                (Some(base_peripheral), Some(base_register), Some(base_field), Some(base_evs)) => {
-                    lookup_in_peripherals(
+        .map(|evs| {
+            if let Some(ref base) = evs.derived_from {
+                let mut parts = base.split('.');
+
+                match (parts.next(), parts.next(), parts.next(), parts.next()) {
+                    (
+                        Some(base_peripheral),
+                        Some(base_register),
+                        Some(base_field),
+                        Some(base_evs),
+                    ) => lookup_in_peripherals(
                         base_peripheral,
                         base_register,
                         base_field,
                         base_evs,
                         all_peripherals,
-                    )
-                }
-                (Some(base_register), Some(base_field), Some(base_evs), None) => {
-                    lookup_in_peripheral(
-                        None,
-                        base_register,
-                        base_field,
-                        base_evs,
-                        all_registers,
-                        peripheral,
-                    )
-                }
-                (Some(base_field), Some(base_evs), None, None) => {
-                    lookup_in_fields(base_evs, base_field, fields, register)
+                    ),
+                    (Some(base_register), Some(base_field), Some(base_evs), None) => {
+                        lookup_in_peripheral(
+                            None,
+                            base_register,
+                            base_field,
+                            base_evs,
+                            all_registers,
+                            peripheral,
+                        )
+                    }
+                    (Some(base_field), Some(base_evs), None, None) => {
+                        lookup_in_fields(base_evs, base_field, fields, register)
+                    }
+                    (Some(base_evs), None, None, None) => lookup_in_register(base_evs, register),
+                    _ => unreachable!(),
                 }
-                (Some(base_evs), None, None, None) => lookup_in_register(base_evs, register),
-                _ => unreachable!(),
+            } else {
+                Ok((evs, None))
             }
-        } else {
-            Ok((evs, None))
         })
         .collect::<Result<Vec<_>>>()?;
 
@@ -894,8 +897,7 @@ fn lookup_in_fields<'f>(
     } else {
         Err(format!(
             "Field {} not found in register {}",
-            base_field,
-            register.name
+            base_field, register.name
         ))?
     }
 }
@@ -921,15 +923,13 @@ fn lookup_in_peripheral<'p>(
         } else {
             Err(format!(
                 "No field {} in register {}",
-                base_field,
-                register.name
+                base_field, register.name
             ))?
         }
     } else {
         Err(format!(
             "No register {} in peripheral {}",
-            base_register,
-            peripheral.name
+            base_register, peripheral.name
         ))?
     }
 }
@@ -942,23 +942,20 @@ fn lookup_in_field<'f>(
 ) -> Result<(&'f EnumeratedValues, Option<Base<'f>>)> {
     for evs in &field.enumerated_values {
         if evs.name.as_ref().map(|s| &**s) == Some(base_evs) {
-            return Ok(
-                (
-                    evs,
-                    Some(Base {
-                        field: &field.name,
-                        register: base_register,
-                        peripheral: base_peripheral,
-                    }),
-                ),
-            );
+            return Ok((
+                evs,
+                Some(Base {
+                    field: &field.name,
+                    register: base_register,
+                    peripheral: base_peripheral,
+                }),
+            ));
         }
     }
 
     Err(format!(
         "No EnumeratedValues {} in field {}",
-        base_evs,
-        field.name
+        base_evs, field.name
     ))?
 }
 
@@ -980,8 +977,7 @@ fn lookup_in_register<'r>(
     match matches.first() {
         None => Err(format!(
             "EnumeratedValues {} not found in register {}",
-            base_evs,
-            register.name
+            base_evs, register.name
         ))?,
         Some(&(evs, field)) => if matches.len() == 1 {
             return Ok((
@@ -1000,8 +996,7 @@ fn lookup_in_register<'r>(
             Err(format!(
                 "Fields {:?} have an \
                  enumeratedValues named {}",
-                fields,
-                base_evs
+                fields, base_evs
             ))?
         },
     }

src/util.rs

@@ -148,9 +148,8 @@ pub fn name_of(register: &Register) -> Cow<str> {
 }
 
 pub fn access_of(register: &Register) -> Access {
-    register
-        .access
-        .unwrap_or_else(|| if let Some(ref fields) = register.fields {
+    register.access.unwrap_or_else(|| {
+        if let Some(ref fields) = register.fields {
             if fields.iter().all(|f| f.access == Some(Access::ReadOnly)) {
                 Access::ReadOnly
             } else if fields.iter().all(|f| f.access == Some(Access::WriteOnly)) {
@@ -160,7 +159,8 @@ pub fn access_of(register: &Register) -> Access {
             }
         } else {
             Access::ReadWrite
-        })
+        }
+    })
 }
 
 /// Turns `n` into an unsuffixed separated hex token