mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2024-12-24 19:09:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

split macro parser into its own crate and improve error handling / reporting

Browse source
This commit is contained in:
Jorge Aparicio 2017-07-14 18:54:54 -05:00
parent 59afbf02aa
commit 98596554b3
10 changed files with 511 additions and 961 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
macros/Cargo.toml
View file

@ -4,8 +4,13 @@ name = "cortex-m-rtfm-macros"
version = "0.1.0"
[dependencies]
error-chain = "0.10.0"
quote = "0.3.15"
syn = "0.11.11"
[dependencies.rtfm-syntax]
git = "https://github.com/japaric/rtfm-syntax"
optional = false
[lib]
proc-macro = true

70
macros/src/analyze.rs Normal file
View file

@ -0,0 +1,70 @@
use std::cmp;
use std::collections::HashMap;
use syn::Ident;
use check::App;
pub type Ownerships = HashMap<Ident, Ownership>;
pub enum Ownership {
/// Owned or co-owned by tasks that run at the same priority
Owned { priority: u8 },
/// Shared by tasks that run at different priorities.
///
/// `ceiling` is the maximum value across all the task priorities
Shared { ceiling: u8 },
}
impl Ownership {
pub fn is_owned(&self) -> bool {
match *self {
Ownership::Owned { .. } => true,
_ => false,
}
}
}
pub fn app(app: &App) -> Ownerships {
let mut ownerships = HashMap::new();
for resource in &app.idle.resources {
ownerships.insert(resource.clone(), Ownership::Owned { priority: 0 });
}
for task in app.tasks.values() {
for resource in &task.resources {
if let Some(ownership) = ownerships.get_mut(resource) {
match *ownership {
Ownership::Owned { priority } => {
if priority == task.priority {
*ownership = Ownership::Owned { priority };
} else {
*ownership = Ownership::Shared {
ceiling: cmp::max(priority, task.priority),
};
}
}
Ownership::Shared { ceiling } => {
if task.priority > ceiling {
*ownership = Ownership::Shared {
ceiling: task.priority,
};
}
}
}
continue;
}
ownerships.insert(
resource.clone(),
Ownership::Owned {
priority: task.priority,
},
);
}
}
ownerships
}

83
macros/src/check.rs
View file

@ -1,12 +1,79 @@
use syntax::Statics;
use util::Ceilings;
use std::collections::HashMap;
pub fn resources(resources: &Statics, ceilings: &Ceilings) {
for resource in resources.keys() {
assert!(
ceilings.get(&resource).is_some(),
"resource {} is unused",
resource
use quote::Tokens;
use rtfm_syntax::{Idents, Idle, Init, Statics};
use syn::Ident;
use error::*;
pub struct App {
pub device: Tokens,
pub idle: Idle,
pub init: Init,
pub resources: Statics,
pub tasks: Tasks,
}
pub type Tasks = HashMap<Ident, Task>;
pub struct Task {
pub enabled: Option<bool>,
pub priority: u8,
pub resources: Idents,
}
pub fn app(app: ::rtfm_syntax::App) -> Result<App> {
let mut tasks = HashMap::new();
for (k, v) in app.tasks {
let name = k.clone();
tasks.insert(
k,
::check::task(v)
.chain_err(|| format!("checking task `{}`", name))?,
);
}
let app = App {
device: app.device,
idle: app.idle,
init: app.init,
resources: app.resources,
tasks,
};
::check::resources(&app)?;
Ok(app)
}
fn resources(app: &App) -> Result<()> {
for resource in app.resources.keys() {
if app.idle.resources.contains(resource) {
continue;
}
if app.tasks
.values()
.any(|task| task.resources.contains(resource))
{
continue;
}
bail!("resource `{}` is unused", resource);
}
Ok(())
}
fn task(task: ::rtfm_syntax::Task) -> Result<Task> {
if let Some(priority) = task.priority {
Ok(Task {
enabled: task.enabled,
priority,
resources: task.resources,
})
} else {
bail!("should contain a `priority` field")
}
}

1
macros/src/error.rs Normal file
View file

@ -0,0 +1 @@
error_chain!();

38
macros/src/lib.rs
View file

@ -1,26 +1,44 @@
#![deny(warnings)]
#![feature(proc_macro)]
#![recursion_limit = "128"]
#[macro_use]
extern crate error_chain;
extern crate proc_macro;
#[macro_use]
extern crate quote;
extern crate rtfm_syntax;
extern crate syn;
mod check;
mod syntax;
mod trans;
mod util;
use proc_macro::TokenStream;
use rtfm_syntax::App;
use error::*;
mod analyze;
mod check;
mod error;
mod trans;
#[proc_macro]
pub fn rtfm(ts: TokenStream) -> TokenStream {
match run(ts) {
Err(e) => panic!("{}", error_chain::ChainedError::display(&e)),
Ok(ts) => ts,
}
}
fn run(ts: TokenStream) -> Result<TokenStream> {
let input = format!("{}", ts);
let app = syntax::parse::app(&input);
let ceilings = util::compute_ceilings(&app);
check::resources(&app.resources, &ceilings);
let app = check::app(App::parse(&input)
.chain_err(|| "parsing the `rtfm!` macro")?).chain_err(
|| "checking the application specification",
)?;
format!("{}", trans::app(&app, &ceilings)).parse().unwrap()
let ownerships = analyze::app(&app);
let tokens = trans::app(&app, &ownerships);
Ok(format!("{}", tokens)
.parse()
.map_err(|_| "BUG: error parsing the generated code")?)
}

51
macros/src/syntax/mod.rs
View file

@ -1,51 +0,0 @@
use std::collections::{HashMap, HashSet};
use syn::Ident;
use quote::Tokens;
pub mod parse;
#[derive(Debug)]
pub struct App {
pub device: Tokens,
pub idle: Idle,
pub init: Init,
pub resources: Statics,
pub tasks: Tasks,
}
#[derive(Debug)]
pub struct Init {
pub path: Tokens,
}
#[derive(Debug)]
pub struct Idle {
pub local: Statics,
pub path: Tokens,
pub resources: HashSet<Ident>,
}
#[derive(Debug)]
pub struct Task {
pub kind: Kind,
pub priority: u8,
pub resources: HashSet<Ident>,
}
#[derive(Debug)]
pub enum Kind {
Exception,
Interrupt { enabled: bool },
}
// $ident: $ty = $expr;
#[derive(Debug)]
pub struct Resource {
pub expr: Tokens,
pub ty: Tokens,
}
pub type Statics = HashMap<Ident, Resource>;
pub type Tasks = HashMap<Ident, Task>;

522
macros/src/syntax/parse.rs
View file

@ -1,522 +0,0 @@
use std::collections::{HashMap, HashSet};
use syn::{self, DelimToken, Ident, IntTy, Lit, Token, TokenTree};
use syntax::{App, Idle, Init, Kind, Resource, Statics, Task, Tasks};
pub fn app(input: &str) -> App {
let tts = syn::parse_token_trees(input).unwrap();
let mut device = None;
let mut init = None;
let mut idle = None;
let mut resources = None;
let mut tasks = None;
let mut tts = tts.into_iter();
while let Some(tt) = tts.next() {
let id = if let TokenTree::Token(Token::Ident(id)) = tt {
id
} else {
panic!("expected ident, found {:?}", tt);
};
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected colon, found {:?}",
tt
);
match id.as_ref() {
"device" => {
assert!(device.is_none(), "duplicated device field");
let mut pieces = vec![];
loop {
if let Some(tt) = tts.next() {
if tt == TokenTree::Token(Token::Comma) {
break;
} else {
pieces.push(tt);
}
} else {
panic!("expected path, found EOM");
}
}
device = Some(quote!(#(#pieces)*));
continue;
}
"idle" => {
assert!(idle.is_none(), "duplicated idle field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
idle = Some(super::parse::idle(block.tts));
} else {
panic!("expected block, found {:?}", tt);
}
}
"init" => {
assert!(init.is_none(), "duplicated init field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
init = Some(super::parse::init(block.tts));
} else {
panic!("expected block, found {:?}", tt);
}
}
"resources" => {
assert!(resources.is_none(), "duplicated resources field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
resources = Some(super::parse::statics(block.tts));
}
}
"tasks" => {
assert!(tasks.is_none(), "duplicated tasks field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
tasks = Some(super::parse::tasks(block.tts));
}
}
id => panic!("unexpected field {}", id),
}
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Comma)),
"expected comma, found {:?}",
tt
);
}
App {
device: device.expect("device field is missing"),
idle: idle.expect("idle field is missing"),
init: init.expect("init field is missing"),
resources: resources.unwrap_or(HashMap::new()),
tasks: tasks.unwrap_or(HashMap::new()),
}
}
pub fn idle(tts: Vec<TokenTree>) -> Idle {
let mut tts = tts.into_iter();
let mut local = None;
let mut path = None;
let mut resources = None;
while let Some(tt) = tts.next() {
let id = if let TokenTree::Token(Token::Ident(id)) = tt {
id
} else {
panic!("expected ident, found {:?}", tt);
};
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected colon, found {:?}",
tt
);
match id.as_ref() {
"local" => {
assert!(local.is_none(), "duplicated local field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
local = Some(super::parse::statics(block.tts));
} else {
panic!("expected block, found {:?}", tt);
}
}
"path" => {
assert!(path.is_none(), "duplicated path field");
let mut pieces = vec![];
loop {
let tt = tts.next()
.expect("expected comma, found end of macro");
if tt == TokenTree::Token(Token::Comma) {
path = Some(quote!(#(#pieces)*));
break;
} else {
pieces.push(tt);
}
}
continue;
}
"resources" => {
assert!(resources.is_none(), "duplicated resources field");
let tt = tts.next();
if let Some(TokenTree::Delimited(array)) = tt {
assert_eq!(
array.delim,
DelimToken::Bracket,
"expected bracket, found {:?}",
array.delim
);
resources = Some(super::parse::idents(array.tts));
} else {
panic!("expected array, found {:?}", tt);
}
}
id => panic!("unexpected field {}", id),
}
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Comma)),
"expected comma, found {:?}",
tt
);
}
Idle {
local: local.unwrap_or(HashMap::new()),
path: path.expect("path field is missing"),
resources: resources.unwrap_or(HashSet::new()),
}
}
pub fn init(tts: Vec<TokenTree>) -> Init {
let mut tts = tts.into_iter();
let mut path = None;
while let Some(tt) = tts.next() {
let id = if let TokenTree::Token(Token::Ident(id)) = tt {
id
} else {
panic!("expected ident, found {:?}", tt);
};
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected colon, found {:?}",
tt
);
match id.as_ref() {
"path" => {
let mut pieces = vec![];
loop {
let tt = tts.next()
.expect("expected comma, found end of macro");
if tt == TokenTree::Token(Token::Comma) {
path = Some(quote!(#(#pieces)*));
break;
} else {
pieces.push(tt);
}
}
}
id => panic!("unexpected field {}", id),
}
}
Init { path: path.expect("path field is missing") }
}
fn idents(tts: Vec<TokenTree>) -> HashSet<Ident> {
let mut idents = HashSet::new();
let mut tts = tts.into_iter().peekable();
while let Some(tt) = tts.next() {
if let TokenTree::Token(Token::Ident(id)) = tt {
assert!(!idents.contains(&id), "ident {} already listed", id);
idents.insert(id);
if let Some(tt) = tts.next() {
assert_eq!(tt, TokenTree::Token(Token::Comma));
if tts.peek().is_none() {
break;
}
} else {
break;
}
} else {
panic!("expected ident, found {:?}", tt);
};
}
idents
}
pub fn statics(tts: Vec<TokenTree>) -> Statics {
let mut resources = HashMap::new();
let mut tts = tts.into_iter();
while let Some(tt) = tts.next() {
let name = if let TokenTree::Token(Token::Ident(ident)) = tt {
ident
} else {
panic!("expected ident, found {:?}", tt);
};
assert!(
!resources.contains_key(&name),
"resource {} already listed",
name
);
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected comma, found {:?}",
tt
);
let mut pieces = vec![];
loop {
if let Some(tt) = tts.next() {
if tt == TokenTree::Token(Token::Eq) {
break;
} else {
pieces.push(tt);
}
} else {
panic!("expected type, found EOM");
}
}
let ty = quote!(#(#pieces)*);
let mut pieces = vec![];
loop {
if let Some(tt) = tts.next() {
if tt == TokenTree::Token(Token::Semi) {
break;
} else {
pieces.push(tt);
}
} else {
panic!("expected expression, found EOM");
}
}
let expr = quote!(#(#pieces)*);
let resource = Resource { expr, ty };
resources.insert(name, resource);
}
resources
}
pub fn tasks(tts: Vec<TokenTree>) -> Tasks {
let mut tasks = HashMap::new();
let mut tts = tts.into_iter();
while let Some(tt) = tts.next() {
let name = if let TokenTree::Token(Token::Ident(ident)) = tt {
ident
} else {
panic!("expected ident, found {:?}", tt);
};
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected colon, found {:?}",
tt
);
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Brace,
"expected brace, found {:?}",
block.delim
);
assert!(!tasks.contains_key(&name), "task {} already listed", name);
tasks.insert(name, super::parse::task(block.tts));
} else {
panic!("expected block, found {:?}", tt);
}
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Comma)),
"expected comma, found {:?}",
tt
);
}
tasks
}
/// Parses the body of a task
///
/// ```
/// enabled: true,
/// priority: 1,
/// resources: [R1, TIM2],
/// ```
///
/// the `enabled` field is optional and distinguishes interrupts from
/// exceptions. Interrupts have an `enabled` field, whereas exceptions don't.
fn task(tts: Vec<TokenTree>) -> Task {
let mut enabled = None;
let mut priority = None;
let mut resources = None;
let mut tts = tts.into_iter();
while let Some(tt) = tts.next() {
let ident = if let TokenTree::Token(Token::Ident(ident)) = tt {
ident
} else {
panic!("expected ident, found {:?}", tt);
};
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Colon)),
"expected colon, found {:?}",
tt
);
match ident.as_ref() {
"enabled" => {
assert!(enabled.is_none(), "duplicated enabled field");
let tt = tts.next();
if let Some(TokenTree::Token(Token::Literal(lit))) = tt {
if let Lit::Bool(b) = lit {
enabled = Some(b);
} else {
panic!("`enabled` value must be a boolean");
}
} else {
panic!("expected literal, found {:?}", tt);
}
}
"priority" => {
assert!(priority.is_none(), "duplicated priority field");
let tt = tts.next();
if let Some(TokenTree::Token(Token::Literal(lit))) = tt {
if let Lit::Int(val, ty) = lit {
assert_eq!(
ty,
IntTy::Unsuffixed,
"`priority` value must be an unsuffixed value"
);
assert!(
val < 256,
"`priority` value must be less than 256"
);
priority = Some(val as u8);
} else {
panic!("enabled value must be a boolean");
}
} else {
panic!("expected literal, found {:?}", tt);
}
}
"resources" => {
assert!(resources.is_none(), "duplicated resources field");
let tt = tts.next();
if let Some(TokenTree::Delimited(block)) = tt {
assert_eq!(
block.delim,
DelimToken::Bracket,
"expected bracket, found {:?}",
block.delim
);
resources = Some(super::parse::idents(block.tts));
} else {
panic!("expected block, found {:?}", tt);
}
}
id => panic!("unexpected field {}", id),
}
let tt = tts.next();
assert_eq!(
tt,
Some(TokenTree::Token(Token::Comma)),
"expected comma, found {:?}",
tt
);
}
let resources = resources.unwrap_or(HashSet::new());
let priority = priority.expect("priority field is missing");
let kind = if let Some(enabled) = enabled {
Kind::Interrupt { enabled }
} else {
Kind::Exception
};
Task {
kind,
priority,
resources,
}
}

612
macros/src/trans.rs
View file

@ -1,21 +1,21 @@
use quote::Tokens;
use syn::Ident;
use quote::{Ident, Tokens};
use syntax::{App, Kind};
use util::{Ceiling, Ceilings};
use analyze::{Ownership, Ownerships};
use check::App;
fn krate() -> Ident {
Ident::new("rtfm")
Ident::from("rtfm")
}
pub fn app(app: &App, ceilings: &Ceilings) -> Tokens {
let mut main = vec![];
pub fn app(app: &App, ownerships: &Ownerships) -> Tokens {
let mut root = vec![];
let mut main = vec![];
super::trans::init(app, &mut main, &mut root);
super::trans::idle(app, ceilings, &mut main, &mut root);
super::trans::resources(app, ceilings, &mut root);
super::trans::tasks(app, ceilings, &mut root);
// ::trans::check(app, &mut main);
::trans::init(app, &mut main, &mut root);
::trans::idle(app, ownerships, &mut main, &mut root);
::trans::resources(app, ownerships, &mut root);
::trans::tasks(app, ownerships, &mut root);
root.push(quote! {
fn main() {
@ -26,127 +26,15 @@ pub fn app(app: &App, ceilings: &Ceilings) -> Tokens {
quote!(#(#root)*)
}
fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
let device = &app.device;
let krate = krate();
let mut tys = vec![quote!(init::Peripherals)];
let mut exprs = vec![quote!(init::Peripherals::all())];
let mut mod_items = vec![];
if !app.resources.is_empty() {
let mut fields = vec![];
let mut lifetime = None;
let mut rexprs = vec![];
for (name, resource) in &app.resources {
lifetime = Some(quote!('a));
let ty = &resource.ty;
fields.push(quote! {
pub #name: &'a mut #krate::Static<#ty>,
});
rexprs.push(quote! {
#name: ::#krate::Static::ref_mut(&mut *super::#name.get()),
});
}
root.push(quote! {
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
pub struct _initResources<#lifetime> {
#(#fields)*
}
});
mod_items.push(quote! {
pub use ::_initResources as Resources;
impl<#lifetime> Resources<#lifetime> {
pub unsafe fn new() -> Self {
Resources {
#(#rexprs)*
}
}
}
});
tys.push(quote!(init::Resources));
exprs.push(quote!(init::Resources::new()));
}
root.push(quote! {
mod init {
pub use ::#device::Peripherals;
#(#mod_items)*
}
});
let mut exceptions = vec![];
let mut interrupts = vec![];
for (name, task) in &app.tasks {
match task.kind {
Kind::Exception => {
if exceptions.is_empty() {
exceptions.push(quote! {
let scb = #device::SCB.borrow(_cs);
});
}
let priority = task.priority;
exceptions.push(quote! {
let prio_bits = #device::NVIC_PRIO_BITS;
let hw = ((1 << prio_bits) - #priority) << (8 - prio_bits);
scb.shpr[#krate::Exception::#name.nr() - 4].write(hw);
});
}
Kind::Interrupt { enabled } => {
if interrupts.is_empty() {
interrupts.push(quote! {
let nvic = #device::NVIC.borrow(_cs);
});
}
let priority = task.priority;
interrupts.push(quote! {
let prio_bits = #device::NVIC_PRIO_BITS;
let hw = ((1 << prio_bits) - #priority) << (8 - prio_bits);
nvic.set_priority(#device::Interrupt::#name, hw);
});
if enabled {
interrupts.push(quote! {
nvic.enable(#device::Interrupt::#name);
});
} else {
interrupts.push(quote! {
nvic.disable(#device::Interrupt::#name);
});
}
}
}
}
let init = &app.init.path;
main.push(quote! {
// type check
let init: fn(#(#tys,)*) = #init;
#krate::atomic(|_cs| unsafe {
init(#(#exprs,)*);
#(#exceptions)*
#(#interrupts)*
});
});
}
// Check that the exceptions / interrupts are valid
// Sadly we can't do this test at expansion time. Instead we'll generate some
// code that won't compile if the interrupt name is invalid.
// fn check(app: &App, main: &mut Vec<Tokens>) {
// }
fn idle(
app: &App,
ceilings: &Ceilings,
ownerships: &Ownerships,
main: &mut Vec<Tokens>,
root: &mut Vec<Tokens>,
) {
@ -160,17 +48,17 @@ fn idle(
!app.idle
.resources
.iter()
.all(|resource| ceilings[resource].is_owned())
.all(|resource| ownerships[resource].is_owned())
{
tys.push(quote!(#krate::Threshold));
exprs.push(quote!(unsafe { #krate::Threshold::new(0) }));
}
if !app.idle.local.is_empty() {
if !app.idle.locals.is_empty() {
let mut lexprs = vec![];
let mut lfields = vec![];
for (name, resource) in &app.idle.local {
for (name, resource) in &app.idle.locals {
let expr = &resource.expr;
let ty = &resource.ty;
@ -184,16 +72,16 @@ fn idle(
}
mod_items.push(quote! {
pub struct Local {
pub struct Locals {
#(#lfields)*
}
});
tys.push(quote!(&'static mut idle::Local));
exprs.push(quote!(unsafe { &mut LOCAL }));
tys.push(quote!(&'static mut idle::Locals));
exprs.push(quote!(unsafe { &mut LOCALS }));
main.push(quote! {
static mut LOCAL: idle::Local = idle::Local {
static mut LOCALS: idle::Locals = idle::Locals {
#(#lexprs)*
};
});
@ -205,10 +93,10 @@ fn idle(
let mut needs_reexport = false;
for name in &app.idle.resources {
if ceilings[name].is_owned() {
if ownerships[name].is_owned() {
if app.resources.get(name).is_some() {
needs_reexport = true;
break
break;
}
}
}
@ -221,7 +109,7 @@ fn idle(
let mut rexprs = vec![];
let mut rfields = vec![];
for name in &app.idle.resources {
if ceilings[name].is_owned() {
if ownerships[name].is_owned() {
lifetime = Some(quote!('a));
if let Some(resource) = app.resources.get(name) {
let ty = &resource.ty;
@ -305,7 +193,282 @@ fn idle(
});
}
fn tasks(app: &App, ceilings: &Ceilings, root: &mut Vec<Tokens>) {
fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
let device = &app.device;
let krate = krate();
let mut tys = vec![quote!(#device::Peripherals)];
let mut exprs = vec![quote!(#device::Peripherals::all())];
let mut mod_items = vec![];
if !app.resources.is_empty() {
let mut fields = vec![];
let mut lifetime = None;
let mut rexprs = vec![];
for (name, resource) in &app.resources {
lifetime = Some(quote!('a));
let ty = &resource.ty;
fields.push(quote! {
pub #name: &'a mut #krate::Static<#ty>,
});
rexprs.push(quote! {
#name: ::#krate::Static::ref_mut(&mut *super::#name.get()),
});
}
root.push(quote! {
#[allow(non_camel_case_types)]
#[allow(non_snake_case)]
pub struct _initResources<#lifetime> {
#(#fields)*
}
});
mod_items.push(quote! {
pub use ::_initResources as Resources;
impl<#lifetime> Resources<#lifetime> {
pub unsafe fn new() -> Self {
Resources {
#(#rexprs)*
}
}
}
});
tys.push(quote!(init::Resources));
exprs.push(quote!(init::Resources::new()));
}
root.push(quote! {
mod init {
pub use ::#device::Peripherals;
#(#mod_items)*
}
});
let mut exceptions = vec![];
let mut interrupts = vec![];
for (name, task) in &app.tasks {
if let Some(enabled) = task.enabled {
// Interrupt. These can be enabled / disabled through the NVIC
if interrupts.is_empty() {
interrupts.push(quote! {
let nvic = #device::NVIC.borrow(_cs);
});
}
let priority = task.priority;
interrupts.push(quote! {
let prio_bits = #device::NVIC_PRIO_BITS;
let hw = ((1 << prio_bits) - #priority) << (8 - prio_bits);
nvic.set_priority(#device::Interrupt::#name, hw);
});
if enabled {
interrupts.push(quote! {
nvic.enable(#device::Interrupt::#name);
});
} else {
interrupts.push(quote! {
nvic.disable(#device::Interrupt::#name);
});
}
} else {
// Exception
if exceptions.is_empty() {
exceptions.push(quote! {
let scb = #device::SCB.borrow(_cs);
});
}
let priority = task.priority;
exceptions.push(quote! {
let prio_bits = #device::NVIC_PRIO_BITS;
let hw = ((1 << prio_bits) - #priority) << (8 - prio_bits);
scb.shpr[#krate::Exception::#name.nr() - 4].write(hw);
});
}
}
let init = &app.init.path;
main.push(quote! {
// type check
let init: fn(#(#tys,)*) = #init;
#krate::atomic(|_cs| unsafe {
init(#(#exprs,)*);
#(#exceptions)*
#(#interrupts)*
});
});
}
fn resources(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
let krate = krate();
let device = &app.device;
let mut items = vec![];
let mut impls = vec![];
for (name, ownership) in ownerships {
let mut impl_items = vec![];
match *ownership {
Ownership::Owned { .. } => {
if let Some(resource) = app.resources.get(name) {
// For owned resources we don't need claim() or borrow(),
// just get()
let expr = &resource.expr;
let ty = &resource.ty;
root.push(quote! {
static #name: #krate::Resource<#ty> =
#krate::Resource::new(#expr);
});
} else {
// Peripheral
continue;
}
}
Ownership::Shared { ceiling } => {
if let Some(resource) = app.resources.get(name) {
let expr = &resource.expr;
let ty = &resource.ty;
root.push(quote! {
static #name: #krate::Resource<#ty> =
#krate::Resource::new(#expr);
});
impl_items.push(quote! {
pub fn borrow<'cs>(
&'cs self,
cs: &'cs #krate::CriticalSection,
) -> &'cs #krate::Static<#ty> {
unsafe { #name.borrow(cs) }
}
pub fn borrow_mut<'cs>(
&'cs mut self,
cs: &'cs #krate::CriticalSection,
) -> &'cs mut #krate::Static<#ty> {
unsafe { #name.borrow_mut(cs) }
}
pub fn claim<R, F>(
&self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&#krate::Static<#ty>,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
pub fn claim_mut<R, F>(
&mut self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&mut #krate::Static<#ty>,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim_mut(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
});
} else {
root.push(quote! {
static #name: #krate::Peripheral<#device::#name> =
#krate::Peripheral::new(#device::#name);
});
impl_items.push(quote! {
pub fn borrow<'cs>(
&'cs self,
cs: &'cs #krate::CriticalSection,
) -> &'cs #device::#name {
unsafe { #name.borrow(cs) }
}
pub fn claim<R, F>(
&self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&#device::#name,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
});
}
impls.push(quote! {
#[allow(dead_code)]
impl _resource::#name {
#(#impl_items)*
}
});
items.push(quote! {
#[allow(non_camel_case_types)]
pub struct #name { _0: () }
impl #name {
pub unsafe fn new() -> Self {
#name { _0: () }
}
}
});
}
}
}
root.push(quote! {
mod _resource {
#(#items)*
}
#(#impls)*
});
}
fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
let device = &app.device;
let krate = krate();
for (name, task) in &app.tasks {
@ -313,12 +476,11 @@ fn tasks(app: &App, ceilings: &Ceilings, root: &mut Vec<Tokens>) {
let mut fields = vec![];
let mut items = vec![];
let device = &app.device;
let mut lifetime = None;
let mut needs_reexport = false;
for name in &task.resources {
match ceilings[name] {
Ceiling::Shared(ceiling) if ceiling > task.priority => {
match ownerships[name] {
Ownership::Shared { ceiling } if ceiling > task.priority => {
fields.push(quote! {
pub #name: super::_resource::#name,
});
@ -405,169 +567,5 @@ fn tasks(app: &App, ceilings: &Ceilings, root: &mut Vec<Tokens>) {
#(#items)*
}
});
}
}
fn resources(app: &App, ceilings: &Ceilings, root: &mut Vec<Tokens>) {
let krate = krate();
let device = &app.device;
let mut items = vec![];
let mut impls = vec![];
for (name, ceiling) in ceilings {
let mut impl_items = vec![];
match *ceiling {
Ceiling::Owned(_) => {
if let Some(resource) = app.resources.get(name) {
// For owned resources we don't need claim() or borrow(),
// just get()
let expr = &resource.expr;
let ty = &resource.ty;
root.push(quote! {
static #name: #krate::Resource<#ty> =
#krate::Resource::new(#expr);
});
} else {
// Peripheral
continue
}
},
Ceiling::Shared(ceiling) => {
if let Some(resource) = app.resources.get(name) {
let expr = &resource.expr;
let ty = &resource.ty;
root.push(quote! {
static #name: #krate::Resource<#ty> =
#krate::Resource::new(#expr);
});
impl_items.push(quote! {
pub fn borrow<'cs>(
&'cs self,
_cs: &'cs #krate::CriticalSection,
) -> &'cs #krate::Static<#ty> {
unsafe {
#krate::Static::ref_(&*#name.get())
}
}
pub fn borrow_mut<'cs>(
&'cs mut self,
_cs: &'cs #krate::CriticalSection,
) -> &'cs mut #krate::Static<#ty> {
unsafe {
#krate::Static::ref_mut(&mut *#name.get())
}
}
pub fn claim<R, F>(
&self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&#krate::Static<#ty>,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
pub fn claim_mut<R, F>(
&mut self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&mut #krate::Static<#ty>,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim_mut(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
});
} else {
root.push(quote! {
static #name: #krate::Peripheral<#device::#name> =
#krate::Peripheral::new(#device::#name);
});
impl_items.push(quote! {
pub fn borrow<'cs>(
&'cs self,
_cs: &'cs #krate::CriticalSection,
) -> &'cs #device::#name {
unsafe {
&*#name.get()
}
}
pub fn claim<R, F>(
&self,
t: &mut #krate::Threshold,
f: F,
) -> R
where
F: FnOnce(
&#device::#name,
&mut #krate::Threshold) -> R
{
unsafe {
#name.claim(
#ceiling,
#device::NVIC_PRIO_BITS,
t,
f,
)
}
}
});
}
impls.push(quote! {
#[allow(dead_code)]
impl _resource::#name {
#(#impl_items)*
}
});
items.push(quote! {
#[allow(non_camel_case_types)]
pub struct #name { _0: () }
impl #name {
pub unsafe fn new() -> Self {
#name { _0: () }
}
}
});
}
}
}
root.push(quote! {
mod _resource {
#(#items)*
}
#(#impls)*
});
}

62
macros/src/util.rs
View file

@ -1,62 +0,0 @@
use std::cmp;
use std::collections::HashMap;
use syn::Ident;
use syntax::App;
pub type Ceilings = HashMap<Ident, Ceiling>;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Ceiling {
// Owned by one or more tasks that have the same priority
Owned(u8),
// Shared by tasks with different priorities
Shared(u8),
}
impl Ceiling {
pub fn is_owned(&self) -> bool {
match *self {
Ceiling::Owned(_) => true,
_ => false,
}
}
}
pub fn compute_ceilings(app: &App) -> Ceilings {
let mut ceilings = HashMap::new();
for resource in &app.idle.resources {
ceilings.insert(resource.clone(), Ceiling::Owned(0));
}
for task in app.tasks.values() {
for resource in &task.resources {
if let Some(ceiling) = ceilings.get_mut(resource) {
match *ceiling {
Ceiling::Owned(current) => {
if current == task.priority {
*ceiling = Ceiling::Owned(current);
} else {
*ceiling = Ceiling::Shared(
cmp::max(current, task.priority),
);
}
}
Ceiling::Shared(old) => {
if task.priority > old {
*ceiling = Ceiling::Shared(task.priority);
}
}
}
continue;
}
ceilings.insert(resource.clone(), Ceiling::Owned(task.priority));
}
}
ceilings
}

28
src/lib.rs
View file

@ -82,6 +82,14 @@ impl<P> Peripheral<P> {
Peripheral { peripheral }
}
#[inline(always)]
pub unsafe fn borrow<'cs>(
&'static self,
_cs: &'cs CriticalSection,
) -> &'cs P {
&*self.peripheral.get()
}
#[inline(always)]
pub unsafe fn claim<R, F>(
&'static self,
@ -123,7 +131,25 @@ pub struct Resource<T> {
impl<T> Resource<T> {
pub const fn new(value: T) -> Self {
Resource { data: UnsafeCell::new(value) }
Resource {
data: UnsafeCell::new(value),
}
}
#[inline(always)]
pub unsafe fn borrow<'cs>(
&'static self,
_cs: &'cs CriticalSection,
) -> &'cs Static<T> {
Static::ref_(&*self.data.get())
}
#[inline(always)]
pub unsafe fn borrow_mut<'cs>(
&'static self,
_cs: &'cs CriticalSection,
) -> &'cs mut Static<T> {
Static::ref_mut(&mut *self.data.get())
}
#[inline(always)]