mirror/rtic
1
0
Fork 0
mirror of https://github.com/rtic-rs/rtic.git synced 2024-11-29 15:04:32 +01:00
Code Issues Projects Releases Packages Wiki Activity

update parser

Browse source 
closes #69

this doesn't change functionality per se but improves diagnostics in some cases. Some hard errors
have becomes warnings, for example: when `resources` is empty, or when `idle.path` is set to the
default `idle` path.
This commit is contained in:
Jorge Aparicio 2018-04-08 18:23:27 +02:00
parent b55581dfe3
commit 7fdf16eab9
13 changed files with 61 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
ci/install.sh
View file

@ -1,14 +1,7 @@
set -euxo pipefail
main() {
case $TARGET in
thumbv*-none-eabi*)
cargo install --list | grep 'xargo v0.3.8' || \
cargo install xargo --vers 0.3.8
rustup component list | grep 'rust-src.*installed' || \
rustup component add rust-src
;;
esac
.
}
main

8
ci/script.sh
View file

@ -9,13 +9,13 @@ main() {
case $TARGET in
thumbv7em-none-eabi*)
xargo check --target $TARGET --features cm7-r0p1
xargo check --target $TARGET --features cm7-r0p1 --examples
cargo check --target $TARGET --features cm7-r0p1
cargo check --target $TARGET --features cm7-r0p1 --examples
;;
esac
xargo check --target $TARGET
xargo check --target $TARGET --examples
cargo check --target $TARGET
cargo check --target $TARGET --examples
}
main

9
macros/Cargo.toml
View file

@ -10,10 +10,11 @@ repository = "https://github.com/japaric/cortex-m-rtfm"
version = "0.3.0"
[dependencies]
error-chain = "0.10.0"
quote = "0.3.15"
rtfm-syntax = "0.2.1"
syn = "0.11.11"
failure = "0.1.1"
proc-macro2 = "0.3.6"
quote = "0.5.1"
rtfm-syntax = { git = "https://github.com/japaric/rtfm-syntax", branch = "syn-up" }
syn = "0.13.1"
[lib]
proc-macro = true

2
macros/src/analyze.rs
View file

@ -40,7 +40,7 @@ pub fn app(app: &App) -> Ownerships {
}
for task in app.tasks.values() {
for resource in &task.resources {
for resource in task.resources.iter() {
if let Some(ownership) = ownerships.get_mut(resource) {
match *ownership {
Ownership::Owned { priority } => {

89
macros/src/check.rs
View file

@ -1,10 +1,8 @@
use std::collections::HashMap;
use syn::{Ident, Path};
use syntax::check::{self, Idle, Init};
use syntax::{self, Resources, Statics};
use syntax::error::*;
use syntax::check::{self, Idents, Idle, Init, Statics};
use syntax::{self, Result};
pub struct App {
pub device: Path,
@ -51,7 +49,7 @@ pub struct Task {
pub kind: Kind,
pub path: Path,
pub priority: u8,
pub resources: Resources,
pub resources: Idents,
}
pub fn app(app: check::App) -> Result<App> {
@ -63,80 +61,16 @@ pub fn app(app: check::App) -> Result<App> {
tasks: app.tasks
.into_iter()
.map(|(k, v)| {
let v =
::check::task(k.as_ref(), v).chain_err(|| format!("checking task `{}`", k))?;
let v = ::check::task(k.as_ref(), v)?;
Ok((k, v))
})
.collect::<Result<_>>()?,
};
::check::resources(&app).chain_err(|| "checking `resources`")?;
Ok(app)
}
fn resources(app: &App) -> Result<()> {
for name in &app.init.resources {
if let Some(resource) = app.resources.get(name) {
ensure!(
resource.expr.is_some(),
"resource `{}`, allocated to `init`, must have an initial value",
name
);
} else {
bail!(
"resource `{}`, allocated to `init`, must be a data resource",
name
);
}
ensure!(
!app.idle.resources.contains(name),
"resources assigned to `init` can't be shared with `idle`"
);
ensure!(
app.tasks
.iter()
.all(|(_, task)| !task.resources.contains(name)),
"resources assigned to `init` can't be shared with tasks"
)
}
for resource in app.resources.keys() {
if app.init.resources.contains(resource) {
continue;
}
if app.idle.resources.contains(resource) {
continue;
}
if app.tasks
.values()
.any(|task| task.resources.contains(resource))
{
continue;
}
bail!("resource `{}` is unused", resource);
}
for (name, task) in &app.tasks {
for resource in &task.resources {
ensure!(
app.resources.contains_key(&resource),
"task {} contains an undeclared resource with name {}",
name,
resource
);
}
}
Ok(())
}
fn task(name: &str, task: syntax::check::Task) -> Result<Task> {
let kind = match Exception::from(name) {
Some(e) => {
@ -147,23 +81,14 @@ fn task(name: &str, task: syntax::check::Task) -> Result<Task> {
Kind::Exception(e)
}
None => {
if task.enabled == Some(true) {
bail!(
"`enabled: true` is the default value; this line can be \
omitted"
);
}
Kind::Interrupt {
None => Kind::Interrupt {
enabled: task.enabled.unwrap_or(true),
}
}
},
};
Ok(Task {
kind,
path: task.path.ok_or("`path` field is missing")?,
path: task.path,
priority: task.priority.unwrap_or(1),
resources: task.resources,
})

21
macros/src/lib.rs
View file

@ -1,19 +1,19 @@
//! Procedural macros of the `cortex-m-rtfm` crate
#![deny(warnings)]
// #![deny(warnings)]
#![feature(proc_macro)]
#![recursion_limit = "128"]
#[macro_use]
extern crate error_chain;
extern crate failure;
extern crate proc_macro;
extern crate proc_macro2;
extern crate syn;
#[macro_use]
extern crate quote;
extern crate rtfm_syntax as syntax;
extern crate syn;
use proc_macro::TokenStream;
use syntax::App;
use syntax::error::*;
use syntax::{App, Result};
mod analyze;
mod check;
@ -170,22 +170,17 @@ mod trans;
#[proc_macro]
pub fn app(ts: TokenStream) -> TokenStream {
match run(ts) {
Err(e) => panic!("{}", error_chain::ChainedError::display(&e)),
Err(e) => panic!("error: {}", e),
Ok(ts) => ts,
}
}
fn run(ts: TokenStream) -> Result<TokenStream> {
let input = format!("{}", ts);
let app = App::parse(&input).chain_err(|| "parsing")?;
let app = syntax::check::app(app).chain_err(|| "checking the AST")?;
let app = App::parse(ts)?.check()?;
let app = check::app(app)?;
let ownerships = analyze::app(&app);
let tokens = trans::app(&app, &ownerships);
Ok(format!("{}", tokens)
.parse()
.map_err(|_| "BUG: error parsing the generated code")?)
Ok(tokens.into())
}

46
macros/src/trans.rs
View file

@ -1,5 +1,6 @@
use quote::{Ident, Tokens};
use syn::{Lit, StrStyle};
use proc_macro2::Span;
use quote::Tokens;
use syn::{Ident, LitStr};
use analyze::Ownerships;
use check::{App, Kind};
@ -10,12 +11,12 @@ fn krate() -> Ident {
pub fn app(app: &App, ownerships: &Ownerships) -> Tokens {
let mut root = vec![];
let mut main = vec![];
let mut main = vec![quote!(#![allow(path_statements)])];
::trans::tasks(app, ownerships, &mut root, &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! {
#[allow(unsafe_code)]
@ -53,7 +54,7 @@ fn idle(app: &App, ownerships: &Ownerships, main: &mut Vec<Tokens>, root: &mut V
let super_ = if needs_reexport {
None
} else {
Some(Ident::new("super"))
Some(Ident::from("super"))
};
let mut rexprs = vec![];
let mut rfields = vec![];
@ -69,7 +70,7 @@ fn idle(app: &App, ownerships: &Ownerships, main: &mut Vec<Tokens>, root: &mut V
pub #name: &'static mut #ty,
});
let _name = Ident::new(format!("_{}", name.as_ref()));
let _name = Ident::from(format!("_{}", name.as_ref()));
rexprs.push(if resource.expr.is_some() {
quote! {
#name: &mut #super_::#_name,
@ -132,10 +133,10 @@ fn idle(app: &App, ownerships: &Ownerships, main: &mut Vec<Tokens>, root: &mut V
// owned resource
if ceiling == 0 {
continue
continue;
}
let _name = Ident::new(format!("_{}", name.as_ref()));
let _name = Ident::from(format!("_{}", name.as_ref()));
let resource = app.resources
.get(name)
.expect(&format!("BUG: resource {} has no definition", name));
@ -262,7 +263,7 @@ fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
&mut #name
},));
} else {
let _name = Ident::new(format!("_{}", name.as_ref()));
let _name = Ident::from(format!("_{}", name.as_ref()));
lifetime = Some(quote!('a));
fields.push(quote! {
@ -309,7 +310,7 @@ fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
let mut fields = vec![];
for (name, resource) in late_resources {
let _name = Ident::new(format!("_{}", name.as_ref()));
let _name = Ident::from(format!("_{}", name.as_ref()));
let ty = &resource.ty;
@ -373,6 +374,8 @@ fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
// Interrupt. These are enabled / disabled through the NVIC
if interrupts.is_empty() {
interrupts.push(quote! {
use #device::Interrupt;
let mut nvic: #device::NVIC = core::mem::transmute(());
});
}
@ -381,16 +384,16 @@ fn init(app: &App, main: &mut Vec<Tokens>, root: &mut Vec<Tokens>) {
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);
nvic.set_priority(Interrupt::#name, hw);
});
if enabled {
interrupts.push(quote! {
nvic.enable(#device::Interrupt::#name);
nvic.enable(Interrupt::#name);
});
} else {
interrupts.push(quote! {
nvic.disable(#device::Interrupt::#name);
nvic.disable(Interrupt::#name);
});
}
}
@ -416,7 +419,7 @@ fn resources(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
let krate = krate();
for name in ownerships.keys() {
let _name = Ident::new(format!("_{}", name.as_ref()));
let _name = Ident::from(format!("_{}", name.as_ref()));
// Declare the static that holds the resource
let resource = app.resources
@ -439,7 +442,7 @@ fn resources(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
}
}
fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>, main: &mut Vec<Tokens>) {
let device = &app.device;
let krate = krate();
@ -453,7 +456,7 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
if has_resources {
for rname in &task.resources {
let ceiling = ownerships[rname].ceiling();
let _rname = Ident::new(format!("_{}", rname.as_ref()));
let _rname = Ident::from(format!("_{}", rname.as_ref()));
let resource = app.resources
.get(rname)
.expect(&format!("BUG: resource {} has no definition", rname));
@ -591,8 +594,8 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
}
let path = &task.path;
let _tname = Ident::new(format!("_{}", tname));
let export_name = Lit::Str(tname.as_ref().to_owned(), StrStyle::Cooked);
let _tname = Ident::from(format!("_{}", tname));
let export_name = LitStr::new(tname.as_ref(), Span::call_site());
root.push(quote! {
#[allow(non_snake_case)]
#[allow(unsafe_code)]
@ -608,11 +611,12 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
#[allow(non_snake_case)]
#[allow(unsafe_code)]
mod #tname {
#[allow(unused_imports)]
use core::marker::PhantomData;
#[allow(dead_code)]
#[deny(const_err)]
const CHECK_PRIORITY: (u8, u8) = (
pub const CHECK_PRIORITY: (u8, u8) = (
#priority - 1,
(1 << ::#device::NVIC_PRIO_BITS) - #priority,
);
@ -620,5 +624,9 @@ fn tasks(app: &App, ownerships: &Ownerships, root: &mut Vec<Tokens>) {
#(#items)*
}
});
// after miri landed (?) rustc won't analyze `const` items unless they are used so we force
// evaluation with this path statement
main.push(quote!(#tname::CHECK_PRIORITY;));
}
}

2
tests/cfail/init-resource-share-idle.rs
View file

@ -19,8 +19,8 @@ app! { //~ proc macro panicked
},
idle: {
// ERROR resources assigned to `init` can't be shared with `idle`
resources: [BUFFER],
//~^ error: this resource is owned by `init` and can't be shared
},
}

2
tests/cfail/init-resource-share-task.rs
View file

@ -21,8 +21,8 @@ app! { //~ proc macro panicked
tasks: {
SYS_TICK: {
path: sys_tick,
// ERROR resources assigned to `init` can't be shared with tasks
resources: [BUFFER],
//~^ error: this resource is owned by `init` and can't be shared
},
},
}

4
tests/cfail/interrupt.rs
View file

@ -8,12 +8,10 @@ extern crate stm32f103xx;
use rtfm::app;
app! {
//~^ error no variant named `EXTI33` found for type
app! { //~ error no variant named `EXTI33` found for type
device: stm32f103xx,
tasks: {
// ERROR this interrupt doesn't exist
EXTI33: {
path: exti33,
},

1
tests/cfail/priority-too-high.rs
View file

@ -9,6 +9,7 @@ extern crate stm32f103xx;
use rtfm::app;
app! { //~ error attempt to subtract with overflow
//~^ error constant evaluation error
device: stm32f103xx,
tasks: {

1
tests/cfail/priority-too-low.rs
View file

@ -9,6 +9,7 @@ extern crate stm32f103xx;
use rtfm::app;
app! { //~ error attempt to subtract with overflow
//~^ error constant evaluation error
device: stm32f103xx,
tasks: {

4
tests/cfail/resource-not-send-sync.rs
View file

@ -7,7 +7,7 @@
extern crate cortex_m_rtfm as rtfm;
extern crate stm32f103xx;
use rtfm::{app, Resource, Threshold};
use rtfm::{app, Threshold};
app! {
device: stm32f103xx,
@ -43,7 +43,7 @@ fn is_sync<T>(_: &T) where T: Sync {}
fn exti0(_t: &mut Threshold, r: EXTI0::Resources) {
// ERROR resource proxies can't be shared between tasks
is_sync(&r.SHARED);
//~^ error the trait bound `*const (): core::marker::Sync` is not satisfied
//~^ error `*const ()` cannot be shared between threads safely
// ERROR resource proxies are not `Send`able across tasks
is_send(&r.SHARED);