diff --git a/src/check.rs b/src/check.rs index 6539e3e0c0712f4c0a37e192501a8f7df1bdad71..0b6dd697cbc7c0bdb58cf6746093b43d8441694d 100644 --- a/src/check.rs +++ b/src/check.rs @@ -175,10 +175,7 @@ fn tasks(tasks: Option<::Tasks>) -> Result<Tasks> { enabled: task.enabled, path: task.path, priority: task.priority, - resources: ::check::resources( - "resources", - task.resources, - )?, + resources: ::check::resources("resources", task.resources)?, }, )) })().chain_err(|| format!("checking task `{}`", name_)) @@ -191,9 +188,7 @@ fn tasks(tasks: Option<::Tasks>) -> Result<Tasks> { /// `crc! { .. }` #[derive(Debug)] -pub struct Crc { - /// `crcs: Crcs` - pub crcs: Option<Crcs>, +pub struct Cro { /// `crcs: Crcs` pub ips: ::Ips, /// `crcs: Crcs` @@ -201,11 +196,10 @@ pub struct Crc { } /// Checks the syntax of the parsed `app!` macro -pub fn crc(crc: ::Crc) -> Result<Crc> { - Ok(Crc { - crcs: crc.crcs, - ips: ::check::ips(crc.ips).chain_err(|| "checking `ips`")?, - ops: ::check::ops(crc.ops).chain_err(|| "checking `ops`")?, +pub fn crc(cro: ::Cro) -> Result<Cro> { + Ok(Cro { + ips: ::check::ips(cro.ips).chain_err(|| "checking `ips`")?, + ops: ::check::ops(cro.ops).chain_err(|| "checking `ops`")?, }) } diff --git a/src/lib.rs b/src/lib.rs index 498ccd0a8410df1400afdbf7c31f96b8b7cfa0f2..1667fcaaf1f01ac2533477e0678ed21b04c3b64e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -120,20 +120,18 @@ pub type Ips = HashMap<Ident, (Ty, Path)>; /// `$($Ident: $Ty = $Expr < $Path,)*` pub type Ops = HashMap<Ident, (Ty, Expr, Path)>; -/// `crc! { .. }` +/// `cro! { .. }` #[derive(Debug)] -pub struct Crc { - /// Inner Crcs (can be None) - pub crcs: Option<Crcs>, +pub struct Cro { /// Input ports (should not be None, given we have interrupts at top level) pub ips: Option<Ips>, /// Output ports (should not be None, given we treat peripherals as Crcs) pub ops: Option<Ops>, } -impl Crc { +impl Cro { /// Parses the contents of the `sys! { .. }` macro pub fn parse(input: &str) -> Result<Self> { - parse::crc(input) + parse::cro(input) } } diff --git a/src/parse.rs b/src/parse.rs index 69699546259a30a71a337df4a816cdc58c42a348..7dff7806d479301a14151e78b95a8174f41b033d 100644 --- a/src/parse.rs +++ b/src/parse.rs @@ -2,13 +2,11 @@ use std::collections::{HashMap, HashSet}; use std::iter::Peekable; use std::slice::Iter; -use syn::{self, DelimToken, Ident, IntTy, Lit, Path, Token, BinOpToken, - TokenTree, Ty}; +use syn::{self, DelimToken, Ident, IntTy, Lit, Path, Token, BinOpToken, TokenTree, Ty}; use error::*; -use {Crc, Crcs, Ips, Ops, App, Idle, Init, Resources, Static, Statics, Task, - Tasks, Expr}; +use {Cro, Ips, Ops, App, Idle, Init, Resources, Static, Statics, Task, Tasks, Expr}; /// Parses the contents of `app! { $App }` pub fn app(input: &str) -> Result<App> { @@ -25,8 +23,7 @@ pub fn app(input: &str) -> Result<App> { "device" => { ensure!(device.is_none(), "duplicated `device` field"); - device = - Some(::parse::path(tts).chain_err(|| "parsing `device`")?); + device = Some(::parse::path(tts).chain_err(|| "parsing `device`")?); } "idle" => { ensure!(idle.is_none(), "duplicated `idle` field"); @@ -41,15 +38,12 @@ pub fn app(input: &str) -> Result<App> { "resources" => { ensure!(resources.is_none(), "duplicated `resources` field"); - resources = Some(::parse::statics(tts).chain_err( - || "parsing `resources`", - )?); + resources = Some(::parse::statics(tts).chain_err(|| "parsing `resources`")?); } "tasks" => { ensure!(tasks.is_none(), "duplicated `tasks` field"); - tasks = - Some(::parse::tasks(tts).chain_err(|| "parsing `tasks`")?); + tasks = Some(::parse::tasks(tts).chain_err(|| "parsing `tasks`")?); } _ => bail!("unknown field: `{}`", key), } @@ -77,11 +71,7 @@ fn bool(tt: Option<&TokenTree>) -> Result<bool> { } /// Parses a delimited token tree -fn delimited<R, F>( - tts: &mut Peekable<Iter<TokenTree>>, - delimiter: DelimToken, - f: F, -) -> Result<R> +fn delimited<R, F>(tts: &mut Peekable<Iter<TokenTree>>, delimiter: DelimToken, f: F) -> Result<R> where F: FnOnce(&[TokenTree]) -> Result<R>, { @@ -147,14 +137,9 @@ fn idle(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Idle> { path = Some(::parse::path(tts)?); } "resources" => { - ensure!( - resources.is_none(), - "duplicated `resources` field" - ); + ensure!(resources.is_none(), "duplicated `resources` field"); - resources = Some(::parse::resources(tts).chain_err( - || "parsing `resources`", - )?); + resources = Some(::parse::resources(tts).chain_err(|| "parsing `resources`")?); } _ => bail!("unknown field: `{}`", key), } @@ -203,10 +188,7 @@ fn resources(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Resources> { let mut tts = tts.iter().peekable(); while let Some(tt) = tts.next() { if let &TokenTree::Token(Token::Ident(ref ident)) = tt { - ensure!( - !idents.contains(ident), - "ident {} listed more than once" - ); + ensure!(!idents.contains(ident), "ident {} listed more than once"); idents.insert(ident.clone()); @@ -280,20 +262,18 @@ fn statics(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Statics> { let mut tts = tts.iter(); while let Some(tt) = tts.next() { match tt { - &TokenTree::Token(Token::Ident(ref id)) - if id.as_ref() == "static" => {} + &TokenTree::Token(Token::Ident(ref id)) if id.as_ref() == "static" => {} _ => { bail!("expected keyword `static`, found {:?}", tt); } } let tt = tts.next(); - let ident = - if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt { - id - } else { - bail!("expected Ident, found {:?}", tt); - }; + let ident = if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt { + id + } else { + bail!("expected Ident, found {:?}", tt); + }; ensure!( !statics.contains_key(ident), @@ -354,33 +334,22 @@ fn task(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Task> { "enabled" => { ensure!(enabled.is_none(), "duplicated `enabled` field"); - enabled = Some(::parse::bool(tts.next()).chain_err( - || "parsing `enabled`", - )?); + enabled = Some(::parse::bool(tts.next()).chain_err(|| "parsing `enabled`")?); } "path" => { ensure!(path.is_none(), "duplicated `path` field"); - path = Some( - ::parse::path(tts).chain_err(|| "parsing `path`")?, - ); + path = Some(::parse::path(tts).chain_err(|| "parsing `path`")?); } "priority" => { ensure!(priority.is_none(), "duplicated `priority` field"); - priority = Some(::parse::u8(tts.next()).chain_err( - || "parsing `priority`", - )?); + priority = Some(::parse::u8(tts.next()).chain_err(|| "parsing `priority`")?); } "resources" => { - ensure!( - resources.is_none(), - "duplicated `resources` field" - ); + ensure!(resources.is_none(), "duplicated `resources` field"); - resources = Some(::parse::resources(tts).chain_err( - || "parsing `resources`", - )?); + resources = Some(::parse::resources(tts).chain_err(|| "parsing `resources`")?); } _ => bail!("unknown field: `{}`", key), } @@ -426,12 +395,7 @@ fn tasks(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Tasks> { /// Parses an integer with type `u8` fn u8(tt: Option<&TokenTree>) -> Result<u8> { - if let Some( - &TokenTree::Token( - Token::Literal(Lit::Int(priority, IntTy::Unsuffixed)), - ), - ) = tt - { + if let Some(&TokenTree::Token(Token::Literal(Lit::Int(priority, IntTy::Unsuffixed)))) = tt { ensure!(priority < 256, "{} is out of the `u8` range", priority); Ok(priority as u8) @@ -441,20 +405,15 @@ fn u8(tt: Option<&TokenTree>) -> Result<u8> { } /// Parses the contents of `crc! { $Crc }` -pub fn crc(input: &str) -> Result<Crc> { +pub fn cro(input: &str) -> Result<Cro> { let tts = syn::parse_token_trees(input)?; - let mut crcs = None; let mut ips = None; let mut ops = None; fields(&tts, |key, tts| { match key.as_ref() { - "crcs" => { - ensure!(crcs.is_none(), "duplicated `crcs` field"); - crcs = Some(::parse::crcs(tts).chain_err(|| "parsing `crcs`")?); - } "ips" => { ensure!(ips.is_none(), "duplicated `ips` field"); @@ -474,11 +433,11 @@ pub fn crc(input: &str) -> Result<Crc> { Ok(()) })?; - Ok(Crc { crcs, ips, ops }) + Ok(Cro { ips, ops }) } - +/* /// Parses `$($Ident: $Path,)*` fn crcs(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Crcs> { ::parse::delimited(tts, DelimToken::Brace, |tts| { @@ -511,6 +470,7 @@ fn crcs(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Crcs> { }) } +*/ /// Parses `$($Ident: $Ty > $Path,)*` fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> { @@ -536,9 +496,8 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> { bail!("expected Colon, found {:?}", tt); } - let ty = - ::parse::ty(&TokenTree::Token(Token::Gt), &mut tts) - .chain_err(|| format!("parsing `type` for {:?}", ident))?; + let ty = ::parse::ty(&TokenTree::Token(Token::Gt), &mut tts) + .chain_err(|| format!("parsing `type` for {:?}", ident))?; let path = ::parse::path(&mut tts).chain_err(|| "parsing `path`")?; tts.next(); @@ -574,14 +533,12 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> { bail!("expected Colon, found {:?}", tt); } - let ty = - ::parse::ty(&TokenTree::Token(Token::Eq), &mut tts) - .chain_err(|| format!("parsing `type` for {:?}", ident))?; + let ty = ::parse::ty(&TokenTree::Token(Token::Eq), &mut tts) + .chain_err(|| format!("parsing `type` for {:?}", ident))?; - let expr = - ::parse::expr(&TokenTree::Token(Token::Lt), &mut tts) - .chain_err(|| format!("parsing `type` for {:?}", ident))?; + let expr = ::parse::expr(&TokenTree::Token(Token::Lt), &mut tts) + .chain_err(|| format!("parsing `type` for {:?}", ident))?; @@ -616,10 +573,7 @@ fn ty(token: &TokenTree, tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ty> { } /// Parses `$Expr ` -fn expr( - token: &TokenTree, - tts: &mut Peekable<Iter<TokenTree>>, -) -> Result<::Expr> { +fn expr(token: &TokenTree, tts: &mut Peekable<Iter<TokenTree>>) -> Result<::Expr> { let mut fragments = vec![]; loop { if let Some(tt) = tts.next() {