Skip to content
Snippets Groups Projects
Commit ae4d120d authored by Per Lindgren's avatar Per Lindgren
Browse files

jap version

parent e2c3257f
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 109 additions and 94 deletions
src/parse.rs
+ 109
− 94
View file @ ae4d120d
......@@ -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 {Cro, 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,16 +262,14 @@ 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 {
let ident = if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
id
} else {
bail!("expected Ident, found {:?}", tt);
......@@ -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),
}
......@@ -521,48 +490,98 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
ident
);
let tt = tts.next();
if let Some(&TokenTree::Token(Token::Colon)) = tt {
} else {
bail!("expected Colon, found {:?}", tt);
}
let mut ty_arg = syn::parse_type(&"()")?;
let mut ty_ret = syn::parse_type(&"()")?;
let _ = ::parse::delimited(&mut tts, DelimToken::Brace, |tts| {
fields(&tts, |key, mut tts| {
match key.as_ref() {
"sig" => {
let tt = tts.next();
let meth =
if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
id
ensure!(id.as_ref() == "fn", "expected `fn` Ident, found {:?}", tt);
} else {
bail!("expected Ident, found {:?}", tt);
};
//let ty_param: Result<Ty> =
let ty_param =
::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
bail!("expected `fn` Ident, found {:?}", tt);
}
ty_arg = ::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
Ok(syn::parse_type(&format!("{}", quote!(#(#tts)*)))?)
})?;
let tt = tts.next();
// let ty_return: Result<Ty> = Ok(syn::parse_type(&"()")?);
let ty_return: Result<Ty> = match tt {
Some(&TokenTree::Token(Token::Comma)) => {
tts.next();
Ok(syn::parse_type(&"()")?)
}
let tt = tts.peek().cloned();
let ty_ret: Result<Ty> = match tt {
Some(&TokenTree::Token(Token::Comma)) => Ok(
syn::parse_type(&"()")?,
),
Some(&TokenTree::Token(Token::RArrow)) => {
::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
}
_ => bail!("expected `-> Type,' or `,` found {:?}", tt),
};
}
"sync" => (),
"async" => (),
_ => bail!("unknown field: `{}`", key),
};
Ok(())
})
})?;
let tt = tts.next();
match tt {
None |
Some(&TokenTree::Token(Token::Comma)) => {}
_ => bail!("expected Comma, found {:?}", tt),
}
// Ok(()))?;
//
//
// let tt = tts.next();
// if let Some(&TokenTree::Token(Token::Colon)) = tt {
// } else {
// bail!("expected Colon, found {:?}", tt);
// }
//
// let tt = tts.next();
// if let Some(&TokenTree::Token(Token::Comma)) = tt {
// let meth =
// if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
// id
// } else {
// bail!("expected Comma, found {:?}", tt);
// bail!("expected Ident, found {:?}", tt);
// };
ips.insert(ident.clone(), (meth.clone(), ty_param, ty_return?));
//
// //let ty_param: Result<Ty> =
// let ty_param =
// ::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
// Ok(syn::parse_type(&format!("{}", quote!(#(#tts)*)))?)
// })?;
//
//
// let tt = tts.next();
// // let ty_return: Result<Ty> = Ok(syn::parse_type(&"()")?);
// let ty_return: Result<Ty> = match tt {
// Some(&TokenTree::Token(Token::Comma)) => {
// tts.next();
// Ok(syn::parse_type(&"()")?)
// }
// Some(&TokenTree::Token(Token::RArrow)) => {
// ::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
// }
// _ => bail!("expected `-> Type,' or `,` found {:?}", tt),
// };
//
// //let tt = tts.next();
// // if let Some(&TokenTree::Token(Token::Comma)) = tt {
// // } else {
// // bail!("expected Comma, found {:?}", tt);
// // };
//
// ips.insert(ident.clone(), (meth.clone(), ty_param, ty_return?));
}
Ok(ips)
......@@ -593,13 +612,11 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> {
bail!("expected Colon, found {:?}", tt);
}
let ty =
::parse::ty(&TokenTree::Token(Token::Eq), &mut tts)
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)
let expr = ::parse::expr(&TokenTree::Token(Token::Lt), &mut tts)
.chain_err(|| format!("parsing `type` for {:?}", ident))?;
......@@ -619,11 +636,12 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> {
fn ty(token: &TokenTree, tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ty> {
let mut fragments = vec![];
loop {
if let Some(tt) = tts.next() {
if let Some(tt) = tts.peek().cloned() {
if tt == token {
break;
} else {
fragments.push(tt);
tts.next();
}
} else {
bail!("expected `{:?}`, found end of macro", token);
......@@ -635,10 +653,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() {
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment