s/local/locals/g, make Peripherals fields uppercase, update docs

Author: japaric

ci/script.sh

@@ -35,8 +35,8 @@ main() {
     # test crate
     cargo init --name foo $td
     echo 'bare-metal = "0.1.0"' >> $td/Cargo.toml
-    echo 'cortex-m = { git = "https://github.com/japaric/cortex-m" }' >> $td/Cargo.toml
-    echo 'cortex-m-rt = { git = "https://github.com/japaric/cortex-m-rt" }' >> $td/Cargo.toml
+    echo 'cortex-m = "0.3.0"' >> $td/Cargo.toml
+    echo 'cortex-m-rt = "0.3.0"' >> $td/Cargo.toml
     echo 'vcell = "0.1.0"' >> $td/Cargo.toml
 
     case $VENDOR in

src/generate.rs

@@ -133,7 +133,7 @@ pub fn device(
         }
 
         ::generate::peripheral(p, &d.peripherals, items, &d.defaults)?;
-        let p = &*p.name;
+        let p = p.name.to_sanitized_upper_case();
         let id = Ident::new(&*p);
         fields.push(quote! {
             #[doc = #p]
@@ -305,12 +305,12 @@ pub fn interrupt(
             #[cfg(feature = "rt")]
             #[macro_export]
             macro_rules! interrupt {
-                ($NAME:ident, $f:ident, local: {
+                ($NAME:ident, $path:path, locals: {
                     $($lvar:ident:$lty:ident = $lval:expr;)*
                 }) => {
                     #[allow(non_snake_case)]
                     mod $NAME {
-                        pub struct Local {
+                        pub struct Locals {
                             $(
                                 pub $lvar: $lty,
                             )*
@@ -323,27 +323,27 @@ pub fn interrupt(
                         // check that the handler exists
                         let _ = $crate::interrupt::Interrupt::$NAME;
 
-                        static mut LOCAL: self::$NAME::Local =
-                            self::$NAME::Local {
+                        static mut LOCALS: self::$NAME::Locals =
+                            self::$NAME::Locals {
                                 $(
                                     $lvar: $lval,
                                 )*
                             };
 
                         // type checking
-                        let f: fn(&mut self::$NAME::Local) = $f;
-                        f(unsafe { &mut LOCAL });
+                        let f: fn(&mut self::$NAME::Locals) = $path;
+                        f(unsafe { &mut LOCALS });
                     }
                 };
-                ($NAME:ident, $f:ident) => {
+                ($NAME:ident, $path:path) => {
                     #[allow(non_snake_case)]
                     #[no_mangle]
                     pub extern "C" fn $NAME() {
                         // check that the handler exists
                         let _ = $crate::interrupt::Interrupt::$NAME;
 
                         // type checking
-                        let f: fn() = $f;
+                        let f: fn() = $path;
                         f();
                     }
                 }

src/lib.rs

@@ -18,9 +18,20 @@
 //!
 //! # Usage
 //!
+//! `svd2rust` supports Cortex-M and MSP430 microcontrollers. The generated
+//! crate can be tailored for either architecture using the `--target` flag. The
+//! flag accepts "cortex-m", "msp430" and "none" as values. "none" can be used
+//! to generate a crate that's architecture agnostic and that should work for
+//! architectures that `svd2rust` doesn't currently know about like the Cortex-A
+//! architecture.
+//!
+//! If the `--target` flag is omitted `svd2rust` assumes the target is the
+//! Cortex-M architecture.
+//!
 //! ```
 //! $ svd2rust -i STM32F30x.svd | rustfmt | tee src/lib.rs
-//! //! Peripheral access API for STM32F30X microcontrollers (generated using svd2rust v0.11.0)
+//! //! Peripheral access API for STM32F30X microcontrollers
+//! //! (generated using svd2rust v0.11.0)
 //!
 //! #![deny(missing_docs)]
 //! #![deny(warnings)]
@@ -79,9 +90,16 @@
 //!
 //! The generated crate depends on:
 //!
-//! - [`cortex-m-rt`](https://crates.io/crates/cortex-m-rt) v0.3.x
-//! - [`cortex-m`](https://crates.io/crates/cortex-m) v0.3.x
+//! - [`bare-metal`](https://crates.io/crates/bare-metal) v0.1.x
 //! - [`vcell`](https://crates.io/crates/vcell) v0.1.x
+//! - [`cortex-m-rt`](https://crates.io/crates/cortex-m-rt) v0.3.x if targeting
+//!   the Cortex-M architecture.
+//! - [`cortex-m`](https://crates.io/crates/cortex-m) v0.3.x if targeting the
+//!   Cortex-M architecture.
+//! - [`msp430`](https://crates.io/crates/msp430) v0.1.x if targeting the MSP430
+//!   architecture.
+//! - [`msp430-rt`](https://crates.io/crates/msp430-rt) v0.1.x if targeting the
+//!   MSP430 architecture.
 //!
 //! # Peripheral API
 //!
@@ -365,10 +383,10 @@
 /// must have signature `fn()`.
 ///
 /// Optionally, a third argument may be used to declare interrupt local data.
-/// The handler will have exclusive access to this data on each invocation. If
-/// the third argument is used then the signature of the handler function must
-/// be `fn(&mut $NAME::Local)` where `$NAME` is the first argument passed to the
-/// macro.
+/// The handler will have exclusive access to these *local* variables on each
+/// invocation. If the third argument is used then the signature of the handler
+/// function must be `fn(&mut $NAME::Locals)` where `$NAME` is the first argument
+/// passed to the macro.
 ///
 /// # Example
 ///
@@ -379,14 +397,14 @@
 ///     print!(".");
 /// }
 ///
-/// interrupt!(TIM3, tick, local: {
+/// interrupt!(TIM3, tick, locals: {
 ///     tick: bool = false;
 /// });
 ///
-/// fn tick(local: &mut TIM3::Local) {
-///     local.tick = !local.tick;
+/// fn tick(locals: &mut TIM3::Locals) {
+///     locals.tick = !locals.tick;
 ///
-///     if local.tick {
+///     if locals.tick {
 ///         println!("Tick");
 ///     } else {
 ///         println!("Tock");
@@ -395,8 +413,8 @@
 /// ```
 #[macro_export]
 macro_rules! interrupt {
-    ($NAME:ident, $body:path) => {};
-    ($NAME:ident, $body:path, local: {
+    ($NAME:ident, $path:path) => {};
+    ($NAME:ident, $path:path, locals: {
         $($lvar:ident: $lty:ty = $lval:expr;)+
     }) => {};
 }